// This is a part of the Active Template Library.
// Copyright (C) 1996-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.

#ifndef __ATLCOM_H__
#define __ATLCOM_H__

#ifndef __cplusplus
#error ATL requires C++ compilation (use a .cpp suffix)
#endif

#ifndef __ATLBASE_H__
#error atlcom.h requires atlbase.h to be included first
#endif

#pragma pack(push, _ATL_PACKING)

EXTERN_C const IID IID_ITargetFrame;

namespace ATL {
#define CComConnectionPointContainerImpl IConnectionPointContainerImpl
#define CComISupportErrorInfoImpl ISupportErrorInfoImpl
#define CComProvideClassInfo2Impl IProvideClassInfoImpl
#define CComDualImpl IDispatchImpl

#ifdef _ATL_DEBUG_QI
#ifndef _ATL_DEBUG
#define _ATL_DEBUG
#endif // _ATL_DEBUG
#endif // _ATL_DEBUG_QI

#ifdef _ATL_DEBUG_QI
#define _ATLDUMPIID(iid, name, hr) AtlDumpIID(iid, name, hr)
#else
#define _ATLDUMPIID(iid, name, hr) hr
#endif

#define _ATL_DEBUG_ADDREF_RELEASE_IMPL(className)\
        virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0;\
        virtual ULONG STDMETHODCALLTYPE Release(void) = 0;

/////////////////////////////////////////////////////////////////////////////
// AtlReportError

inline HRESULT WINAPI AtlReportError(const CLSID& clsid, UINT nID, const IID& iid,
    HRESULT hRes, HINSTANCE hInst)
{
    return AtlSetErrorInfo(clsid, (LPCOLESTR)MAKEINTRESOURCE(nID), 0, NULL, iid, hRes, hInst);
}

inline HRESULT WINAPI AtlReportError(const CLSID& clsid, UINT nID, DWORD dwHelpID,
    LPCOLESTR lpszHelpFile, const IID& iid, HRESULT hRes, HINSTANCE hInst)
{
    return AtlSetErrorInfo(clsid, (LPCOLESTR)MAKEINTRESOURCE(nID), dwHelpID,
        lpszHelpFile, iid, hRes, hInst);
}

#ifndef OLE2ANSI
inline HRESULT WINAPI AtlReportError(const CLSID& clsid, LPCSTR lpszDesc,
    DWORD dwHelpID, LPCSTR lpszHelpFile, const IID& iid, HRESULT hRes)
{
    ATLASSERT(lpszDesc != NULL);
    if (lpszDesc == NULL)
        return E_POINTER;
    USES_CONVERSION_EX;
    LPCOLESTR pwszDesc = A2COLE_EX(lpszDesc, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
    if (pwszDesc == NULL)
        return E_OUTOFMEMORY;

    LPCWSTR pwzHelpFile = NULL;
    if (lpszHelpFile != NULL) {
        pwzHelpFile = A2CW_EX(lpszHelpFile, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
        if (pwzHelpFile == NULL)
            return E_OUTOFMEMORY;
    }

    return AtlSetErrorInfo(clsid, pwszDesc, dwHelpID, pwzHelpFile, iid, hRes, NULL);
}

inline HRESULT WINAPI AtlReportError(const CLSID& clsid, LPCSTR lpszDesc,
    const IID& iid, HRESULT hRes)
{
    ATLASSERT(lpszDesc != NULL);
    if (lpszDesc == NULL)
        return E_POINTER;
    USES_CONVERSION_EX;
    LPCOLESTR pwszDesc = A2COLE_EX(lpszDesc, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
    if (pwszDesc == NULL)
        return E_OUTOFMEMORY;

    return AtlSetErrorInfo(clsid, pwszDesc, 0, NULL, iid, hRes, NULL);
}
#endif

inline HRESULT WINAPI AtlReportError(const CLSID& clsid, LPCOLESTR lpszDesc,
    const IID& iid, HRESULT hRes)
{
    return AtlSetErrorInfo(clsid, lpszDesc, 0, NULL, iid, hRes, NULL);
}

inline HRESULT WINAPI AtlReportError(const CLSID& clsid, LPCOLESTR lpszDesc, DWORD dwHelpID,
    LPCOLESTR lpszHelpFile, const IID& iid, HRESULT hRes)
{
    return AtlSetErrorInfo(clsid, lpszDesc, dwHelpID, lpszHelpFile, iid, hRes, NULL);
}

//////////////////////////////////////////////////////////////////////////////
// IPersistImpl
template <class T>
class ATL_NO_VTABLE IPersistImpl : public IPersist {
public:
    STDMETHOD(GetClassID)(CLSID* pClassID)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistImpl::GetClassID\n"));
        if (pClassID == NULL)
            return E_FAIL;
        *pClassID = T::GetObjectCLSID();
        return S_OK;
    }
};


//////////////////////////////////////////////////////////////////////////////
// CComDispatchDriver / Specialization of CComQIPtr<IDispatch, IID_IDispatch>
class CComDispatchDriver {
public:
    CComDispatchDriver()
    {
        p = NULL;
    }
    CComDispatchDriver(IDispatch* lp)
    {
        if ((p = lp) != NULL)
            p->AddRef();
    }
    CComDispatchDriver(IUnknown* lp)
    {
        p = NULL;
        if (lp != NULL)
            lp->QueryInterface(IID_IDispatch, (void**)&p);
    }
    ~CComDispatchDriver() { if (p) p->Release(); }
    void Release() { if (p) p->Release(); p = NULL; }
    operator IDispatch* () { return p; }
    IDispatch& operator*() { ATLASSERT(p != NULL); return *p; }
    IDispatch** operator&() { ATLASSERT(p == NULL); return &p; }
    IDispatch* operator->() { ATLASSERT(p != NULL); return p; }
    IDispatch* operator=(IDispatch* lp) { return (IDispatch*)AtlComPtrAssign((IUnknown**)&p, lp); }
    IDispatch* operator=(IUnknown* lp)
    {
        return (IDispatch*)AtlComQIPtrAssign((IUnknown**)&p, lp, IID_IDispatch);
    }
    BOOL operator!() { return (p == NULL) ? TRUE : FALSE; }

    HRESULT GetPropertyByName(LPCOLESTR lpsz, VARIANT* pVar)
    {
        ATLASSERT(p);
        ATLASSERT(pVar);
        DISPID dwDispID;
        HRESULT hr = GetIDOfName(lpsz, &dwDispID);
        if (SUCCEEDED(hr))
            hr = GetProperty(p, dwDispID, pVar);
        return hr;
    }
    HRESULT GetProperty(DISPID dwDispID, VARIANT* pVar)
    {
        ATLASSERT(p);
        return GetProperty(p, dwDispID, pVar);
    }
    HRESULT PutPropertyByName(LPCOLESTR lpsz, VARIANT* pVar)
    {
        ATLASSERT(p);
        ATLASSERT(pVar);
        DISPID dwDispID;
        HRESULT hr = GetIDOfName(lpsz, &dwDispID);
        if (SUCCEEDED(hr))
            hr = PutProperty(p, dwDispID, pVar);
        return hr;
    }
    HRESULT PutProperty(DISPID dwDispID, VARIANT* pVar)
    {
        ATLASSERT(p);
        return PutProperty(p, dwDispID, pVar);
    }
    HRESULT GetIDOfName(LPCOLESTR lpsz, DISPID* pdispid)
    {
        return p->GetIDsOfNames(IID_NULL, (LPOLESTR*)&lpsz, 1, LOCALE_USER_DEFAULT, pdispid);
    }
    // Invoke a method by DISPID with no parameters
    HRESULT Invoke0(DISPID dispid, VARIANT* pvarRet = NULL)
    {
        DISPPARAMS dispparams = { NULL, NULL, 0, 0 };
        return p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparams, pvarRet, NULL, NULL);
    }
    // Invoke a method by name with no parameters
    HRESULT Invoke0(LPCOLESTR lpszName, VARIANT* pvarRet = NULL)
    {
        HRESULT hr;
        DISPID dispid;
        hr = GetIDOfName(lpszName, &dispid);
        if (SUCCEEDED(hr))
            hr = Invoke0(dispid, pvarRet);
        return hr;
    }
    // Invoke a method by DISPID with a single parameter
    HRESULT Invoke1(DISPID dispid, VARIANT* pvarParam1, VARIANT* pvarRet = NULL)
    {
        DISPPARAMS dispparams = { pvarParam1, NULL, 1, 0 };
        return p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparams, pvarRet, NULL, NULL);
    }
    // Invoke a method by name with a single parameter
    HRESULT Invoke1(LPCOLESTR lpszName, VARIANT* pvarParam1, VARIANT* pvarRet = NULL)
    {
        HRESULT hr;
        DISPID dispid;
        hr = GetIDOfName(lpszName, &dispid);
        if (SUCCEEDED(hr))
            hr = Invoke1(dispid, pvarParam1, pvarRet);
        return hr;
    }
    // Invoke a method by DISPID with two parameters
    HRESULT Invoke2(DISPID dispid, VARIANT* pvarParam1, VARIANT* pvarParam2, VARIANT* pvarRet = NULL)
    {
        if (pvarParam1 == NULL || pvarParam2 == NULL)
            return E_INVALIDARG;

        CComVariant varArgs[2] = { *pvarParam2, *pvarParam1 };
        DISPPARAMS dispparams = { &varArgs[0], NULL, 2, 0 };
        return p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparams, pvarRet, NULL, NULL);
    }
    // Invoke a method by name with two parameters
    HRESULT Invoke2(LPCOLESTR lpszName, VARIANT* pvarParam1, VARIANT* pvarParam2, VARIANT* pvarRet = NULL)
    {
        HRESULT hr;
        DISPID dispid;
        hr = GetIDOfName(lpszName, &dispid);
        if (SUCCEEDED(hr))
            hr = Invoke2(dispid, pvarParam1, pvarParam2, pvarRet);
        return hr;
    }
    // Invoke a method by DISPID with N parameters
    HRESULT InvokeN(DISPID dispid, VARIANT* pvarParams, int nParams, VARIANT* pvarRet = NULL)
    {
        DISPPARAMS dispparams = { pvarParams, NULL, (UINT)nParams, 0 };
        return p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparams, pvarRet, NULL, NULL);
    }
    // Invoke a method by name with Nparameters
    HRESULT InvokeN(LPCOLESTR lpszName, VARIANT* pvarParams, int nParams, VARIANT* pvarRet = NULL)
    {
        HRESULT hr;
        DISPID dispid;
        hr = GetIDOfName(lpszName, &dispid);
        if (SUCCEEDED(hr))
            hr = InvokeN(dispid, pvarParams, nParams, pvarRet);
        return hr;
    }
    static HRESULT GetProperty(IDispatch* pDisp, DISPID dwDispID,
        VARIANT* pVar)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("CPropertyHelper::GetProperty\n"));
        ATLASSERT(pVar != NULL);
        if (pVar == NULL)
            return E_POINTER;

        if (pDisp == NULL)
            return E_INVALIDARG;

        DISPPARAMS dispparamsNoArgs = { NULL, NULL, 0, 0 };
        return pDisp->Invoke(dwDispID, IID_NULL,
            LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
            &dispparamsNoArgs, pVar, NULL, NULL);
    }

    static HRESULT PutProperty(IDispatch* pDisp, DISPID dwDispID,
        VARIANT* pVar)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("CPropertyHelper::PutProperty\n"));
        ATLASSERT(pVar != NULL);
        if (pVar == NULL)
            return E_POINTER;

        if (pDisp == NULL)
            return E_INVALIDARG;

        DISPPARAMS dispparams = { NULL, NULL, 1, 1 };
        dispparams.rgvarg = pVar;
        DISPID dispidPut = DISPID_PROPERTYPUT;
        dispparams.rgdispidNamedArgs = &dispidPut;

        if (pVar->vt == VT_UNKNOWN || pVar->vt == VT_DISPATCH ||
            (pVar->vt & VT_ARRAY) || (pVar->vt & VT_BYREF)) {
            HRESULT hr = pDisp->Invoke(dwDispID, IID_NULL,
                LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF,
                &dispparams, NULL, NULL, NULL);
            if (SUCCEEDED(hr))
                return hr;
        }

        return pDisp->Invoke(dwDispID, IID_NULL,
            LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT,
            &dispparams, NULL, NULL, NULL);
    }

    IDispatch* p;
};

//////////////////////////////////////////////////////////////////////////////
// CFakeFirePropNotifyEvent
class CFakeFirePropNotifyEvent {
public:
    static HRESULT FireOnRequestEdit(IUnknown* /*pUnk*/, DISPID /*dispID*/)
    {
        return S_OK;
    }
    static HRESULT FireOnChanged(IUnknown* /*pUnk*/, DISPID /*dispID*/)
    {
        return S_OK;
    }
};
typedef CFakeFirePropNotifyEvent _ATL_PROP_NOTIFY_EVENT_CLASS;

//////////////////////////////////////////////////////////////////////////////
// ATL Persistence

struct ATL_PROPMAP_ENTRY {
    LPCOLESTR szDesc;
    DISPID dispid;
    const CLSID* pclsidPropPage;
    const IID* piidDispatch;
    size_t dwOffsetData;
    DWORD dwSizeData;
    VARTYPE vt;
};

// This one is DEPRECATED and is used for ATL 2.X controls
// it includes an implicit m_sizeExtent
#define BEGIN_PROPERTY_MAP(theClass) \
        typedef _ATL_PROP_NOTIFY_EVENT_CLASS __ATL_PROP_NOTIFY_EVENT_CLASS; \
        typedef theClass _PropMapClass; \
        static ATL_PROPMAP_ENTRY* GetPropertyMap()\
        {\
                static ATL_PROPMAP_ENTRY pPropMap[] = \
                { \
                        {OLESTR("_cx"), 0, &CLSID_NULL, NULL, offsetof(_PropMapClass, m_sizeExtent.cx), sizeof(long), VT_UI4}, \
                        {OLESTR("_cy"), 0, &CLSID_NULL, NULL, offsetof(_PropMapClass, m_sizeExtent.cy), sizeof(long), VT_UI4},

// This one can be used on any type of object, but does not
// include the implicit m_sizeExtent
#define BEGIN_PROP_MAP(theClass) \
        typedef _ATL_PROP_NOTIFY_EVENT_CLASS __ATL_PROP_NOTIFY_EVENT_CLASS; \
        typedef theClass _PropMapClass; \
        static ATL_PROPMAP_ENTRY* GetPropertyMap()\
        {\
                static ATL_PROPMAP_ENTRY pPropMap[] = \
                {

#define PROP_ENTRY(szDesc, dispid, clsid) \
                {OLESTR(szDesc), dispid, &clsid, &IID_IDispatch, 0, 0, 0},

#define PROP_ENTRY_EX(szDesc, dispid, clsid, iidDispatch) \
                {OLESTR(szDesc), dispid, &clsid, &iidDispatch, 0, 0, 0},

#define PROP_PAGE(clsid) \
                {NULL, NULL, &clsid, &IID_NULL, 0, 0, 0},

#define PROP_DATA_ENTRY(szDesc, member, vt) \
                {OLESTR(szDesc), 0, &CLSID_NULL, NULL, offsetof(_PropMapClass, member), sizeof(((_PropMapClass*)0)->member), vt},

#define END_PROPERTY_MAP() \
                        {NULL, 0, NULL, &IID_NULL, 0, 0, 0} \
                }; \
                return pPropMap; \
        }

#define END_PROP_MAP() \
                        {NULL, 0, NULL, &IID_NULL, 0, 0, 0} \
                }; \
                return pPropMap; \
        }


#ifdef _ATL_DLL
ATLAPI AtlIPersistStreamInit_Load(LPSTREAM pStm, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk);
#else
ATLINLINE ATLAPI AtlIPersistStreamInit_Load(LPSTREAM pStm, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk)
{
    ATLASSERT(pMap != NULL);
    if (pStm == NULL || pMap == NULL || pThis == NULL || pUnk == NULL)
        return E_INVALIDARG;

    HRESULT hr = S_OK;
    DWORD dwVer;
    hr = pStm->Read(&dwVer, sizeof(DWORD), NULL);
    if (FAILED(hr))
        return hr;
    if (dwVer > _ATL_VER)
        return E_FAIL;

    CComPtr<IDispatch> pDispatch;
    const IID* piidOld = NULL;
    for (int i = 0; pMap[i].pclsidPropPage != NULL; i++) {
        if (pMap[i].szDesc == NULL)
            continue;

        // check if raw data entry
        if (pMap[i].dwSizeData != 0) {
            void* pData = (void*)(pMap[i].dwOffsetData + (DWORD_PTR)pThis);
            hr = pStm->Read(pData, pMap[i].dwSizeData, NULL);
            if (FAILED(hr))
                return hr;
            continue;
        }

        CComVariant var;

        hr = var.ReadFromStream(pStm);
        if (FAILED(hr))
            break;

        if (pMap[i].piidDispatch != piidOld) {
            pDispatch.Release();
            if (FAILED(pUnk->QueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch))) {
                ATLTRACE2(atlTraceCOM, 0, _T("Failed to get a dispatch pointer for property #%i\n"), i);
                hr = E_FAIL;
                break;
            }
            piidOld = pMap[i].piidDispatch;
        }

        if (FAILED(CComDispatchDriver::PutProperty(pDispatch, pMap[i].dispid, &var))) {
            ATLTRACE2(atlTraceCOM, 0, _T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
            hr = E_FAIL;
            break;
        }
    }
    return hr;
}
#endif //_ATL_DLL

#ifdef _ATL_DLL
ATLAPI AtlIPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk);
#else
ATLINLINE ATLAPI AtlIPersistStreamInit_Save(LPSTREAM pStm,
    BOOL /* fClearDirty */, ATL_PROPMAP_ENTRY* pMap,
    void* pThis, IUnknown* pUnk)
{
    ATLASSERT(pMap != NULL);
    if (pStm == NULL || pMap == NULL || pThis == NULL || pUnk == NULL)
        return E_INVALIDARG;
    DWORD dw = _ATL_VER;
    HRESULT hr = pStm->Write(&dw, sizeof(DWORD), NULL);
    if (FAILED(hr))
        return hr;

    CComPtr<IDispatch> pDispatch;
    const IID* piidOld = NULL;
    for (int i = 0; pMap[i].pclsidPropPage != NULL; i++) {
        if (pMap[i].szDesc == NULL)
            continue;

        // check if raw data entry
        if (pMap[i].dwSizeData != 0) {
            void* pData = (void*)(pMap[i].dwOffsetData + (DWORD_PTR)pThis);
            hr = pStm->Write(pData, pMap[i].dwSizeData, NULL);
            if (FAILED(hr))
                return hr;
            continue;
        }

        CComVariant var;
        if (pMap[i].piidDispatch != piidOld) {
            pDispatch.Release();
            if (FAILED(pUnk->QueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch))) {
                ATLTRACE2(atlTraceCOM, 0, _T("Failed to get a dispatch pointer for property #%i\n"), i);
                hr = E_FAIL;
                break;
            }
            piidOld = pMap[i].piidDispatch;
        }

        if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var))) {
            ATLTRACE2(atlTraceCOM, 0, _T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
            hr = E_FAIL;
            break;
        }

        hr = var.WriteToStream(pStm);
        if (FAILED(hr))
            break;
    }
    return hr;
}
#endif //_ATL_DLL


#ifdef _ATL_DLL
ATLAPI AtlIPersistPropertyBag_Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk);
#else
ATLINLINE ATLAPI AtlIPersistPropertyBag_Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk)
{
    if (pPropBag == NULL || pMap == NULL || pThis == NULL || pUnk == NULL)
        return E_INVALIDARG;

    CComPtr<IDispatch> pDispatch;
    const IID* piidOld = NULL;
    for (int i = 0; pMap[i].pclsidPropPage != NULL; i++) {
        if (pMap[i].szDesc == NULL)
            continue;

        CComVariant var;
        var.vt = pMap[i].vt;
        // If raw entry skip it - we don't handle it for property bags just yet
        if (pMap[i].dwSizeData != 0) {
            void* pData = (void*)(pMap[i].dwOffsetData + (DWORD_PTR)pThis);
            HRESULT hr = pPropBag->Read(pMap[i].szDesc, &var, pErrorLog);
            if (SUCCEEDED(hr)) {
                // check the type - we only deal with limited set
                switch (pMap[i].vt) {
                case VT_UI1:
                case VT_I1:
                    *((BYTE*)pData) = var.bVal;
                    break;
                case VT_BOOL:
                    *((VARIANT_BOOL*)pData) = var.boolVal;
                    break;
                case VT_UI2:
                    *((short*)pData) = var.iVal;
                    break;
                case VT_UI4:
                case VT_INT:
                case VT_UINT:
                    *((long*)pData) = var.lVal;
                    break;
                }
            }
            continue;
        }

        if (pMap[i].piidDispatch != piidOld) {
            pDispatch.Release();
            if (FAILED(pUnk->QueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch))) {
                ATLTRACE2(atlTraceCOM, 0, _T("Failed to get a dispatch pointer for property #%i\n"), i);
                return E_FAIL;
            }
            piidOld = pMap[i].piidDispatch;
        }

        if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var))) {
            ATLTRACE2(atlTraceCOM, 0, _T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
            return E_FAIL;
        }

        HRESULT hr = pPropBag->Read(pMap[i].szDesc, &var, pErrorLog);
        if (FAILED(hr)) {
            USES_CONVERSION_EX;
            LPCTSTR lp = OLE2CT_EX(pMap[i].szDesc, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);

            if (hr == E_INVALIDARG) {
                if (lp == NULL)
                    ATLTRACE2(atlTraceCOM, 0, _T("Property not in Bag\n"));
                else
                    ATLTRACE2(atlTraceCOM, 0, _T("Property %s not in Bag\n"), lp);
            } else {
                // Many containers return different ERROR values for Member not found
                if (lp == NULL)
                    ATLTRACE2(atlTraceCOM, 0, _T("Error attempting to read Property from PropertyBag \n"));
                else
                    ATLTRACE2(atlTraceCOM, 0, _T("Error attempting to read Property %s from PropertyBag \n"), lp);
            }
            continue;
        }

        if (FAILED(CComDispatchDriver::PutProperty(pDispatch, pMap[i].dispid, &var))) {
            ATLTRACE2(atlTraceCOM, 0, _T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
            return E_FAIL;
        }
    }
    return S_OK;
}
#endif //_ATL_DLL

#ifdef _ATL_DLL
ATLAPI AtlIPersistPropertyBag_Save(LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties, ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk);
#else
ATLINLINE ATLAPI AtlIPersistPropertyBag_Save(LPPROPERTYBAG pPropBag,
    BOOL /* fClearDirty */, BOOL /* fSaveAllProperties */,
    ATL_PROPMAP_ENTRY* pMap, void* pThis, IUnknown* pUnk)
{
    if (pPropBag == NULL) {
        ATLTRACE2(atlTraceCOM, 0, _T("PropBag pointer passed in was invalid\n"));
        return E_INVALIDARG;
    }
    if (pMap == NULL || pThis == NULL || pUnk == NULL)
        return E_INVALIDARG;

    CComPtr<IDispatch> pDispatch;
    const IID* piidOld = NULL;
    for (int i = 0; pMap[i].pclsidPropPage != NULL; i++) {
        if (pMap[i].szDesc == NULL)
            continue;

        CComVariant var;

        // If raw entry skip it - we don't handle it for property bags just yet
        if (pMap[i].dwSizeData != 0) {
            void* pData = (void*)(pMap[i].dwOffsetData + (DWORD_PTR)pThis);
            // check the type - we only deal with limited set
            bool bTypeOK = false;
            switch (pMap[i].vt) {
            case VT_UI1:
            case VT_I1:
                var.bVal = *((BYTE*)pData);
                bTypeOK = true;
                break;
            case VT_BOOL:
                var.boolVal = *((VARIANT_BOOL*)pData);
                bTypeOK = true;
                break;
            case VT_UI2:
                var.iVal = *((short*)pData);
                bTypeOK = true;
                break;
            case VT_UI4:
            case VT_INT:
            case VT_UINT:
                var.lVal = *((long*)pData);
                bTypeOK = true;
                break;
            }
            if (bTypeOK) {
                var.vt = pMap[i].vt;
                HRESULT hr = pPropBag->Write(pMap[i].szDesc, &var);
                if (FAILED(hr))
                    return hr;
            }
            continue;
        }

        if (pMap[i].piidDispatch != piidOld) {
            pDispatch.Release();
            if (FAILED(pUnk->QueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch))) {
                ATLTRACE2(atlTraceCOM, 0, _T("Failed to get a dispatch pointer for property #%i\n"), i);
                return E_FAIL;
            }
            piidOld = pMap[i].piidDispatch;
        }

        if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var))) {
            ATLTRACE2(atlTraceCOM, 0, _T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
            return E_FAIL;
        }

        if (var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH) {
            if (var.punkVal == NULL) {
                ATLTRACE2(atlTraceCOM, 0, _T("Warning skipping empty IUnknown in Save\n"));
                continue;
            }
        }

        HRESULT hr = pPropBag->Write(pMap[i].szDesc, &var);
        if (FAILED(hr))
            return hr;
    }
    return S_OK;
}
#endif //_ATL_DLL


//////////////////////////////////////////////////////////////////////////////
// IPersistStreamInitImpl
template <class T>
class ATL_NO_VTABLE IPersistStreamInitImpl : public IPersistStreamInit {
public:
    // IPersist
    STDMETHOD(GetClassID)(CLSID* pClassID)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStreamInitImpl::GetClassID\n"));
        ATLASSERT(pClassID != NULL);
        if (pClassID == NULL)
            return E_POINTER;
        *pClassID = T::GetObjectCLSID();
        return S_OK;
    }

    // IPersistStream
    STDMETHOD(IsDirty)()
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStreamInitImpl::IsDirty\n"));
        T* pT = static_cast<T*>(this);
        return (pT->m_bRequiresSave) ? S_OK : S_FALSE;
    }
    STDMETHOD(Load)(LPSTREAM pStm)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStreamInitImpl::Load\n"));
        T* pT = static_cast<T*>(this);
        return pT->IPersistStreamInit_Load(pStm, T::GetPropertyMap());
    }
    STDMETHOD(Save)(LPSTREAM pStm, BOOL fClearDirty)
    {
        T* pT = static_cast<T*>(this);
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStreamInitImpl::Save\n"));
        return pT->IPersistStreamInit_Save(pStm, fClearDirty, T::GetPropertyMap());
    }
    STDMETHOD(GetSizeMax)(ULARGE_INTEGER FAR* /* pcbSize */)
    {
        ATLTRACENOTIMPL(_T("IPersistStreamInitImpl::GetSizeMax"));
    }

    // IPersistStreamInit
    STDMETHOD(InitNew)()
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStreamInitImpl::InitNew\n"));
        return S_OK;
    }

    HRESULT IPersistStreamInit_Load(LPSTREAM pStm, ATL_PROPMAP_ENTRY* pMap)
    {
        T* pT = static_cast<T*>(this);
        HRESULT hr = AtlIPersistStreamInit_Load(pStm, pMap, pT, pT->GetUnknown());
        if (SUCCEEDED(hr))
            pT->m_bRequiresSave = FALSE;
        return hr;

    }
    HRESULT IPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty, ATL_PROPMAP_ENTRY* pMap)
    {
        T* pT = static_cast<T*>(this);
        return AtlIPersistStreamInit_Save(pStm, fClearDirty, pMap, pT, pT->GetUnknown());
    }
};

//////////////////////////////////////////////////////////////////////////////
// IPersistStorageImpl
template <class T>
class ATL_NO_VTABLE IPersistStorageImpl : public IPersistStorage {
public:
    // IPersist
    STDMETHOD(GetClassID)(CLSID* pClassID)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::GetClassID\n"));
        ATLASSERT(pClassID != NULL);
        if (pClassID == NULL)
            return E_POINTER;
        *pClassID = T::GetObjectCLSID();
        return S_OK;
    }

    // IPersistStorage
    STDMETHOD(IsDirty)(void)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::IsDirty\n"));
        CComPtr<IPersistStreamInit> p;
        p.p = IPSI_GetIPersistStreamInit();
        return (p != NULL) ? p->IsDirty() : E_FAIL;
    }
    STDMETHOD(InitNew)(IStorage*)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::InitNew\n"));
        CComPtr<IPersistStreamInit> p;
        p.p = IPSI_GetIPersistStreamInit();
        return (p != NULL) ? p->InitNew() : E_FAIL;
    }
    STDMETHOD(Load)(IStorage* pStorage)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::Load\n"));
        if (pStorage == NULL)
            return E_INVALIDARG;
        CComPtr<IPersistStreamInit> p;
        p.p = IPSI_GetIPersistStreamInit();
        HRESULT hr = E_FAIL;
        if (p != NULL) {
            CComPtr<IStream> spStream;
            hr = pStorage->OpenStream(OLESTR("Contents"), NULL,
                STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &spStream);
            if (SUCCEEDED(hr))
                hr = p->Load(spStream);
        }
        return hr;
    }
    STDMETHOD(Save)(IStorage* pStorage, BOOL fSameAsLoad)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::Save\n"));
        if (pStorage == NULL)
            return E_INVALIDARG;
        CComPtr<IPersistStreamInit> p;
        p.p = IPSI_GetIPersistStreamInit();
        HRESULT hr = E_FAIL;
        if (p != NULL) {
            CComPtr<IStream> spStream;
            static LPCOLESTR vszContents = OLESTR("Contents");
            hr = pStorage->CreateStream(vszContents,
                STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
                0, 0, &spStream);
            if (SUCCEEDED(hr))
                hr = p->Save(spStream, fSameAsLoad);
        }
        return hr;
    }
    STDMETHOD(SaveCompleted)(IStorage* /* pStorage */)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::SaveCompleted\n"));
        return S_OK;
    }
    STDMETHOD(HandsOffStorage)(void)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistStorageImpl::HandsOffStorage\n"));
        return S_OK;
    }
private:
    IPersistStreamInit* IPSI_GetIPersistStreamInit();
};

template <class T>
IPersistStreamInit* IPersistStorageImpl<T>::IPSI_GetIPersistStreamInit()
{
    T* pT = static_cast<T*>(this);
    IPersistStreamInit* p;
    if (FAILED(pT->GetUnknown()->QueryInterface(IID_IPersistStreamInit, (void**)&p)))
        pT->_InternalQueryInterface(IID_IPersistStreamInit, (void**)&p);
    return p;
}


//////////////////////////////////////////////////////////////////////////////
// IPersistPropertyBagImpl
template <class T>
class ATL_NO_VTABLE IPersistPropertyBagImpl : public IPersistPropertyBag {
public:
    // IPersist
    STDMETHOD(GetClassID)(CLSID* pClassID)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistPropertyBagImpl::GetClassID\n"));
        ATLASSERT(pClassID != NULL);
        if (pClassID == NULL)
            return E_POINTER;
        *pClassID = T::GetObjectCLSID();
        return S_OK;
    }

    // IPersistPropertyBag
    //
    STDMETHOD(InitNew)()
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistPropertyBagImpl::InitNew\n"));
        return S_OK;
    }
    STDMETHOD(Load)(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistPropertyBagImpl::Load\n"));
        T* pT = static_cast<T*>(this);
        ATL_PROPMAP_ENTRY* pMap = T::GetPropertyMap();
        ATLASSERT(pMap != NULL);
        return pT->IPersistPropertyBag_Load(pPropBag, pErrorLog, pMap);
    }
    STDMETHOD(Save)(LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IPersistPropertyBagImpl::Save\n"));
        T* pT = static_cast<T*>(this);
        ATL_PROPMAP_ENTRY* pMap = T::GetPropertyMap();
        ATLASSERT(pMap != NULL);
        return pT->IPersistPropertyBag_Save(pPropBag, fClearDirty, fSaveAllProperties, pMap);
    }
    HRESULT IPersistPropertyBag_Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY* pMap)
    {
        T* pT = static_cast<T*>(this);
        HRESULT hr = AtlIPersistPropertyBag_Load(pPropBag, pErrorLog, pMap, pT, pT->GetUnknown());
        if (SUCCEEDED(hr))
            pT->m_bRequiresSave = FALSE;
        return hr;
    }
    HRESULT IPersistPropertyBag_Save(LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties, ATL_PROPMAP_ENTRY* pMap)
    {
        T* pT = static_cast<T*>(this);
        return AtlIPersistPropertyBag_Save(pPropBag, fClearDirty, fSaveAllProperties, pMap, pT, pT->GetUnknown());
    }
};

//////////////////////////////////////////////////////////////////////////////
// CSecurityDescriptor
class CSecurityDescriptor {
public:
    CSecurityDescriptor();
    ~CSecurityDescriptor();

public:
    HRESULT Attach(PSECURITY_DESCRIPTOR pSelfRelativeSD);
    HRESULT AttachObject(HANDLE hObject);
    HRESULT Initialize();
    HRESULT InitializeFromProcessToken(BOOL bDefaulted = FALSE);
    HRESULT InitializeFromThreadToken(BOOL bDefaulted = FALSE, BOOL bRevertToProcessToken = TRUE);
    HRESULT SetOwner(PSID pOwnerSid, BOOL bDefaulted = FALSE);
    HRESULT SetGroup(PSID pGroupSid, BOOL bDefaulted = FALSE);
    HRESULT Allow(LPCTSTR pszPrincipal, DWORD dwAccessMask);
    HRESULT Deny(LPCTSTR pszPrincipal, DWORD dwAccessMask);
    HRESULT Revoke(LPCTSTR pszPrincipal);

    // utility functions
    // Any PSID you get from these functions should be free()ed
    static HRESULT SetPrivilege(LPCTSTR Privilege, BOOL bEnable = TRUE, HANDLE hToken = NULL);
    static HRESULT GetTokenSids(HANDLE hToken, PSID* ppUserSid, PSID* ppGroupSid);
    static HRESULT GetProcessSids(PSID* ppUserSid, PSID* ppGroupSid = NULL);
    static HRESULT GetThreadSids(PSID* ppUserSid, PSID* ppGroupSid = NULL, BOOL bOpenAsSelf = FALSE);
    static HRESULT CopyACL(PACL pDest, PACL pSrc);
    static HRESULT GetCurrentUserSID(PSID* ppSid);
    static HRESULT GetPrincipalSID(LPCTSTR pszPrincipal, PSID* ppSid);
    static HRESULT AddAccessAllowedACEToACL(PACL* Acl, LPCTSTR pszPrincipal, DWORD dwAccessMask);
    static HRESULT AddAccessDeniedACEToACL(PACL* Acl, LPCTSTR pszPrincipal, DWORD dwAccessMask);
    static HRESULT RemovePrincipalFromACL(PACL Acl, LPCTSTR pszPrincipal);

    operator PSECURITY_DESCRIPTOR()
    {
        return m_pSD;
    }

public:
    PSECURITY_DESCRIPTOR m_pSD;
    PSID m_pOwner;
    PSID m_pGroup;
    PACL m_pDACL;
    PACL m_pSACL;
};

inline CSecurityDescriptor::CSecurityDescriptor()
{
    m_pSD = NULL;
    m_pOwner = NULL;
    m_pGroup = NULL;
    m_pDACL = NULL;
    m_pSACL = NULL;
}

inline CSecurityDescriptor::~CSecurityDescriptor()
{
    if (m_pSD)
        delete m_pSD;
    if (m_pOwner)
        free(m_pOwner);
    if (m_pGroup)
        free(m_pGroup);
    if (m_pDACL)
        free(m_pDACL);
    if (m_pSACL)
        free(m_pSACL);
}

inline HRESULT CSecurityDescriptor::Initialize()
{
    if (m_pSD) {
        delete m_pSD;
        m_pSD = NULL;
    }
    if (m_pOwner) {
        free(m_pOwner);
        m_pOwner = NULL;
    }
    if (m_pGroup) {
        free(m_pGroup);
        m_pGroup = NULL;
    }
    if (m_pDACL) {
        free(m_pDACL);
        m_pDACL = NULL;
    }
    if (m_pSACL) {
        free(m_pSACL);
        m_pSACL = NULL;
    }

    ATLTRY(m_pSD = new SECURITY_DESCRIPTOR);
    if (m_pSD == NULL)
        return E_OUTOFMEMORY;

    if (!InitializeSecurityDescriptor(m_pSD, SECURITY_DESCRIPTOR_REVISION)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        delete m_pSD;
        m_pSD = NULL;
        ATLASSERT(FALSE);
        return hr;
    }
    return S_OK;
}

inline HRESULT CSecurityDescriptor::InitializeFromProcessToken(BOOL bDefaulted)
{
    PSID pUserSid = NULL;
    PSID pGroupSid = NULL;

    HRESULT hr = Initialize();
    if (FAILED(hr))
        return hr;
    hr = GetProcessSids(&pUserSid, &pGroupSid);
    if (SUCCEEDED(hr)) {
        hr = SetOwner(pUserSid, bDefaulted);
        if (SUCCEEDED(hr))
            hr = SetGroup(pGroupSid, bDefaulted);
    }
    if (pUserSid != NULL)
        free(pUserSid);
    if (pGroupSid != NULL)
        free(pGroupSid);

    if (FAILED(hr)) {
        delete m_pSD;
        m_pSD = NULL;

        free(m_pOwner);
        m_pOwner = NULL;

        ATLASSERT(FALSE);
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::InitializeFromThreadToken(BOOL bDefaulted, BOOL bRevertToProcessToken)
{
    PSID pUserSid = NULL;
    PSID pGroupSid = NULL;

    HRESULT hr = Initialize();
    if (FAILED(hr))
        return hr;

    hr = GetThreadSids(&pUserSid, &pGroupSid);
    if (HRESULT_CODE(hr) == ERROR_NO_TOKEN && bRevertToProcessToken)
        hr = GetProcessSids(&pUserSid, &pGroupSid);
    if (SUCCEEDED(hr)) {
        hr = SetOwner(pUserSid, bDefaulted);
        if (SUCCEEDED(hr))
            hr = SetGroup(pGroupSid, bDefaulted);
    }
    if (pUserSid != NULL)
        free(pUserSid);
    if (pGroupSid != NULL)
        free(pGroupSid);

    if (FAILED(hr)) {
        delete m_pSD;
        m_pSD = NULL;

        free(m_pOwner);
        m_pOwner = NULL;

        ATLASSERT(FALSE);
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::SetOwner(PSID pOwnerSid, BOOL bDefaulted)
{
    ATLASSERT(m_pSD);

    // Mark the SD as having no owner
    if (!SetSecurityDescriptorOwner(m_pSD, NULL, bDefaulted)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        return hr;
    }

    if (m_pOwner) {
        free(m_pOwner);
        m_pOwner = NULL;
    }

    // If they asked for no owner don't do the copy
    if (pOwnerSid == NULL)
        return S_OK;

    if (!IsValidSid(pOwnerSid)) {
        return E_INVALIDARG;
    }

    // Make a copy of the Sid for the return value
    DWORD dwSize = GetLengthSid(pOwnerSid);

    m_pOwner = (PSID)malloc(dwSize);
    if (m_pOwner == NULL)
        return E_OUTOFMEMORY;
    if (!CopySid(dwSize, m_pOwner, pOwnerSid)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        free(m_pOwner);
        m_pOwner = NULL;
        return hr;
    }

    ATLASSERT(IsValidSid(m_pOwner));

    if (!SetSecurityDescriptorOwner(m_pSD, m_pOwner, bDefaulted)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        free(m_pOwner);
        m_pOwner = NULL;
        return hr;
    }

    return S_OK;
}

inline HRESULT CSecurityDescriptor::SetGroup(PSID pGroupSid, BOOL bDefaulted)
{
    ATLASSERT(m_pSD);

    // Mark the SD as having no Group
    if (!SetSecurityDescriptorGroup(m_pSD, NULL, bDefaulted)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        return hr;
    }

    if (m_pGroup) {
        free(m_pGroup);
        m_pGroup = NULL;
    }

    // If they asked for no Group don't do the copy
    if (pGroupSid == NULL)
        return S_OK;

    if (!IsValidSid(pGroupSid)) {
        return E_INVALIDARG;
    }

    // Make a copy of the Sid for the return value
    DWORD dwSize = GetLengthSid(pGroupSid);

    m_pGroup = (PSID)malloc(dwSize);
    if (m_pGroup == NULL)
        return E_OUTOFMEMORY;
    if (!CopySid(dwSize, m_pGroup, pGroupSid)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        free(m_pGroup);
        m_pGroup = NULL;
        return hr;
    }

    ATLASSERT(IsValidSid(m_pGroup));

    if (!SetSecurityDescriptorGroup(m_pSD, m_pGroup, bDefaulted)) {
        HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        free(m_pGroup);
        m_pGroup = NULL;
        return hr;
    }

    return S_OK;
}

inline HRESULT CSecurityDescriptor::Allow(LPCTSTR pszPrincipal, DWORD dwAccessMask)
{
    HRESULT hr = AddAccessAllowedACEToACL(&m_pDACL, pszPrincipal, dwAccessMask);
    if (SUCCEEDED(hr)) {
        if (!SetSecurityDescriptorDacl(m_pSD, TRUE, m_pDACL, FALSE)) {
            hr = AtlHresultFromLastError();
        }
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::Deny(LPCTSTR pszPrincipal, DWORD dwAccessMask)
{
    HRESULT hr = AddAccessDeniedACEToACL(&m_pDACL, pszPrincipal, dwAccessMask);
    if (SUCCEEDED(hr)) {
        if (!SetSecurityDescriptorDacl(m_pSD, TRUE, m_pDACL, FALSE)) {
            hr = AtlHresultFromLastError();
        }
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::Revoke(LPCTSTR pszPrincipal)
{
    HRESULT hr = RemovePrincipalFromACL(m_pDACL, pszPrincipal);
    if (SUCCEEDED(hr)) {
        if (!SetSecurityDescriptorDacl(m_pSD, TRUE, m_pDACL, FALSE)) {
            hr = AtlHresultFromLastError();
        }
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::GetProcessSids(PSID* ppUserSid, PSID* ppGroupSid)
{
    BOOL bRes;
    HRESULT hr;
    HANDLE hToken = NULL;
    if (ppUserSid)
        *ppUserSid = NULL;
    if (ppGroupSid)
        *ppGroupSid = NULL;
    bRes = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken);
    if (!bRes) {
        // Couldn't open process token
        hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        return hr;
    }
    hr = GetTokenSids(hToken, ppUserSid, ppGroupSid);
    CloseHandle(hToken);
    return hr;
}

inline HRESULT CSecurityDescriptor::GetThreadSids(PSID* ppUserSid, PSID* ppGroupSid, BOOL bOpenAsSelf)
{
    BOOL bRes;
    HRESULT hr;
    HANDLE hToken = NULL;
    if (ppUserSid)
        *ppUserSid = NULL;
    if (ppGroupSid)
        *ppGroupSid = NULL;
    bRes = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, bOpenAsSelf, &hToken);
    if (!bRes) {
        // Couldn't open thread token
        hr = HRESULT_FROM_WIN32(GetLastError());
        return hr;
    }
    hr = GetTokenSids(hToken, ppUserSid, ppGroupSid);
    CloseHandle(hToken);
    return hr;
}

inline HRESULT CSecurityDescriptor::GetTokenSids(HANDLE hToken, PSID* ppUserSid, PSID* ppGroupSid)
{
    DWORD dwSize = 0;
    HRESULT hr = E_FAIL;
    DWORD dwErr;
    PTOKEN_USER ptkUser = NULL;
    PTOKEN_PRIMARY_GROUP ptkGroup = NULL;

    if (ppUserSid)
        *ppUserSid = NULL;
    if (ppGroupSid)
        *ppGroupSid = NULL;

    if (ppUserSid) {
        // Get length required for TokenUser by specifying buffer length of 0
        GetTokenInformation(hToken, TokenUser, NULL, 0, &dwSize);
        dwErr = GetLastError();
        if (dwErr != ERROR_INSUFFICIENT_BUFFER) {
            // Expected ERROR_INSUFFICIENT_BUFFER
            ATLASSERT(FALSE);
            hr = AtlHresultFromWin32(dwErr);
            goto failed;
        }

        ptkUser = (TOKEN_USER*)malloc(dwSize);
        if (ptkUser == NULL) {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
        // Get Sid of process token.
        if (!GetTokenInformation(hToken, TokenUser, ptkUser, dwSize, &dwSize)) {
            // Couldn't get user info
            hr = HRESULT_FROM_WIN32(GetLastError());
            ATLASSERT(FALSE);
            goto failed;
        }

        // Make a copy of the Sid for the return value
        dwSize = GetLengthSid(ptkUser->User.Sid);

        PSID pSid;
        pSid = (PSID)malloc(dwSize);
        if (pSid == NULL) {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
        if (!CopySid(dwSize, pSid, ptkUser->User.Sid)) {
            hr = HRESULT_FROM_WIN32(GetLastError());
            free(pSid);
            ATLASSERT(FALSE);
            goto failed;
        }

        ATLASSERT(IsValidSid(pSid));
        *ppUserSid = pSid;
        free(ptkUser);
        ptkUser = NULL;
    }
    if (ppGroupSid) {
        // Get length required for TokenPrimaryGroup by specifying buffer length of 0
        GetTokenInformation(hToken, TokenPrimaryGroup, NULL, 0, &dwSize);
        dwErr = GetLastError();
        if (dwErr != ERROR_INSUFFICIENT_BUFFER) {
            // Expected ERROR_INSUFFICIENT_BUFFER
            ATLASSERT(FALSE);
            hr = AtlHresultFromWin32(dwErr);
            goto failed;
        }

        ptkGroup = (TOKEN_PRIMARY_GROUP*)malloc(dwSize);
        if (ptkGroup == NULL) {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
        // Get Sid of process token.
        if (!GetTokenInformation(hToken, TokenPrimaryGroup, ptkGroup, dwSize, &dwSize)) {
            // Couldn't get user info
            hr = HRESULT_FROM_WIN32(GetLastError());
            ATLASSERT(FALSE);
            goto failed;
        }

        // Make a copy of the Sid for the return value
        dwSize = GetLengthSid(ptkGroup->PrimaryGroup);

        PSID pSid;
        pSid = (PSID)malloc(dwSize);
        if (pSid == NULL) {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
        if (!CopySid(dwSize, pSid, ptkGroup->PrimaryGroup)) {
            hr = HRESULT_FROM_WIN32(GetLastError());
            free(pSid);
            ATLASSERT(FALSE);
            goto failed;
        }

        ATLASSERT(IsValidSid(pSid));

        *ppGroupSid = pSid;
        free(ptkGroup);
        ptkGroup = NULL;
    }

    return S_OK;

failed:
    if (ptkUser)
        free(ptkUser);
    if (ptkGroup)
        free(ptkGroup);
    return hr;
}


inline HRESULT CSecurityDescriptor::GetCurrentUserSID(PSID* ppSid)
{
    HANDLE tkHandle;

    if (ppSid == NULL) {
        return E_POINTER;
    }

    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &tkHandle)) {
        TOKEN_USER* tkUser;
        DWORD tkSize;
        DWORD sidLength;

        // Call to get size information for alloc
        GetTokenInformation(tkHandle, TokenUser, NULL, 0, &tkSize);
        DWORD dwErr = GetLastError();
        if (dwErr != ERROR_INSUFFICIENT_BUFFER) {
            // Expected ERROR_INSUFFICIENT_BUFFER
            HRESULT hr = AtlHresultFromWin32(dwErr);
            ATLASSERT(FALSE);
            CloseHandle(tkHandle);
            return hr;
        }
        tkUser = (TOKEN_USER*)malloc(tkSize);
        if (tkUser == NULL) {
            CloseHandle(tkHandle);
            return E_OUTOFMEMORY;
        }

        // Now make the real call
        if (GetTokenInformation(tkHandle, TokenUser, tkUser, tkSize, &tkSize)) {
            sidLength = GetLengthSid(tkUser->User.Sid);
            *ppSid = (PSID)malloc(sidLength);
            if (*ppSid == NULL) {
                CloseHandle(tkHandle);
                free(tkUser);
                return E_OUTOFMEMORY;
            }
            if (!CopySid(sidLength, *ppSid, tkUser->User.Sid)) {
                HRESULT hr = AtlHresultFromWin32(dwErr);
                CloseHandle(tkHandle);
                free(tkUser);
                free(*ppSid);
                *ppSid = NULL;
                return hr;
            }

            CloseHandle(tkHandle);
            free(tkUser);
            return S_OK;
        } else {
            HRESULT hr = AtlHresultFromLastError();
            CloseHandle(tkHandle);
            free(tkUser);
            return hr;
        }
    }
    return HRESULT_FROM_WIN32(GetLastError());
}


inline HRESULT CSecurityDescriptor::GetPrincipalSID(LPCTSTR pszPrincipal, PSID* ppSid)
{
    LPTSTR pszRefDomain = NULL;
    DWORD dwDomainSize = 0;
    DWORD dwSidSize = 0;
    SID_NAME_USE snu;

    if (ppSid == NULL) {
        return E_POINTER;
    }
    if (pszPrincipal == NULL) {
        return E_INVALIDARG;
    }

    *ppSid = NULL;

    // Call to get size info for alloc
    LookupAccountName(NULL, pszPrincipal, *ppSid, &dwSidSize, pszRefDomain, &dwDomainSize, &snu);

    DWORD dwErr = GetLastError();
    if (dwErr != ERROR_INSUFFICIENT_BUFFER)
        return HRESULT_FROM_WIN32(dwErr);

    ATLTRY(pszRefDomain = new TCHAR[dwDomainSize]);
    if (pszRefDomain == NULL)
        return E_OUTOFMEMORY;

    *ppSid = (PSID)malloc(dwSidSize);
    if (*ppSid != NULL) {
        if (!LookupAccountName(NULL, pszPrincipal, *ppSid, &dwSidSize, pszRefDomain, &dwDomainSize, &snu)) {
            HRESULT hr = AtlHresultFromLastError();
            free(*ppSid);
            *ppSid = NULL;
            delete[] pszRefDomain;
            return hr;
        }
        delete[] pszRefDomain;
        return S_OK;
    }
    delete[] pszRefDomain;
    return E_OUTOFMEMORY;
}


inline HRESULT CSecurityDescriptor::Attach(PSECURITY_DESCRIPTOR pSelfRelativeSD)
{
    PACL    pDACL = NULL;
    PACL    pSACL = NULL;
    BOOL    bDACLPresent, bSACLPresent;
    BOOL    bDefaulted;
    PSID    pUserSid;
    PSID    pGroupSid;

    if (pSelfRelativeSD == NULL || !IsValidSecurityDescriptor(pSelfRelativeSD))
        return E_INVALIDARG;

    HRESULT hr = Initialize();
    if (FAILED(hr))
        return hr;

    // get the existing DACL.
    if (!GetSecurityDescriptorDacl(pSelfRelativeSD, &bDACLPresent, &pDACL, &bDefaulted))
        goto failed;

    if (bDACLPresent) {
        if (pDACL) {
            // allocate new DACL.
            m_pDACL = (PACL)malloc(pDACL->AclSize);
            if (m_pDACL == NULL) {
                hr = E_OUTOFMEMORY;
                goto failedMemory;
            }

            // initialize the DACL
            if (!InitializeAcl(m_pDACL, pDACL->AclSize, ACL_REVISION))
                goto failed;

            // copy the ACES
            hr = CopyACL(m_pDACL, pDACL);
            if (FAILED(hr))
                goto failedMemory;

            if (!IsValidAcl(m_pDACL))
                goto failed;
        }

        // set the DACL
        if (!SetSecurityDescriptorDacl(m_pSD, m_pDACL ? TRUE : FALSE, m_pDACL, bDefaulted))
            goto failed;
    }

    // get the existing SACL.
    if (!GetSecurityDescriptorSacl(pSelfRelativeSD, &bSACLPresent, &pSACL, &bDefaulted))
        goto failed;

    if (bSACLPresent) {
        if (pSACL) {
            // allocate new SACL.
            m_pSACL = (PACL)malloc(pSACL->AclSize);
            if (m_pSACL == NULL) {
                hr = E_OUTOFMEMORY;
                goto failedMemory;
            }

            // initialize the SACL
            if (!InitializeAcl(m_pSACL, pSACL->AclSize, ACL_REVISION))
                goto failed;

            // copy the ACES
            hr = CopyACL(m_pSACL, pSACL);
            if (FAILED(hr))
                goto failedMemory;

            if (!IsValidAcl(m_pSACL))
                goto failed;
        }

        // set the SACL
        if (!SetSecurityDescriptorSacl(m_pSD, m_pSACL ? TRUE : FALSE, m_pSACL, bDefaulted))
            goto failed;
    }

    if (!GetSecurityDescriptorOwner(pSelfRelativeSD, &pUserSid, &bDefaulted))
        goto failed;

    if (FAILED(SetOwner(pUserSid, bDefaulted)))
        goto failed;

    if (!GetSecurityDescriptorGroup(pSelfRelativeSD, &pGroupSid, &bDefaulted))
        goto failed;

    if (FAILED(SetGroup(pGroupSid, bDefaulted)))
        goto failed;

    if (!IsValidSecurityDescriptor(m_pSD)) {
        hr = E_FAIL;
        goto failedMemory;
    }

    return S_OK;

failed:
    hr = AtlHresultFromLastError();

failedMemory:
    if (m_pDACL) {
        free(m_pDACL);
        m_pDACL = NULL;
    }
    if (m_pSACL) {
        free(m_pSACL);
        m_pSACL = NULL;
    }
    if (m_pSD) {
        free(m_pSD);
        m_pSD = NULL;
    }
    return hr;
}

inline HRESULT CSecurityDescriptor::AttachObject(HANDLE hObject)
{
    HRESULT hr;
    DWORD dwSize = 0;
    PSECURITY_DESCRIPTOR pSD = NULL;

    GetKernelObjectSecurity(hObject, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
        DACL_SECURITY_INFORMATION, pSD, 0, &dwSize);

    DWORD dwErr = GetLastError();
    if (dwErr != ERROR_INSUFFICIENT_BUFFER)
        return HRESULT_FROM_WIN32(dwErr);

    pSD = (PSECURITY_DESCRIPTOR)malloc(dwSize);
    if (pSD == NULL)
        return E_OUTOFMEMORY;

    if (!GetKernelObjectSecurity(hObject, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
        DACL_SECURITY_INFORMATION, pSD, dwSize, &dwSize)) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        free(pSD);
        return hr;
    }

    hr = Attach(pSD);
    free(pSD);
    return hr;
}


inline HRESULT CSecurityDescriptor::CopyACL(PACL pDest, PACL pSrc)
{
    ACL_SIZE_INFORMATION aclSizeInfo;
    LPVOID pAce;
    ACE_HEADER* aceHeader;

    if (pDest == NULL)
        return E_POINTER;
    if (pSrc == NULL)
        return S_OK;

    if (!GetAclInformation(pSrc, (LPVOID)&aclSizeInfo, sizeof(ACL_SIZE_INFORMATION), AclSizeInformation))
        return HRESULT_FROM_WIN32(GetLastError());

    // Copy all of the ACEs to the new ACL
    for (UINT i = 0; i < aclSizeInfo.AceCount; i++) {
        if (!GetAce(pSrc, i, &pAce))
            return HRESULT_FROM_WIN32(GetLastError());

        aceHeader = (ACE_HEADER*)pAce;

        if (!AddAce(pDest, ACL_REVISION, 0xffffffff, pAce, aceHeader->AceSize))
            return HRESULT_FROM_WIN32(GetLastError());
    }

    return S_OK;
}

inline HRESULT CSecurityDescriptor::AddAccessDeniedACEToACL(PACL* ppAcl, LPCTSTR pszPrincipal, DWORD dwAccessMask)
{
    ACL_SIZE_INFORMATION aclSizeInfo;
    int aclSize;
    PSID principalSID;
    PACL oldACL, newACL = NULL;

    if (ppAcl == NULL)
        return E_POINTER;

    if (pszPrincipal == NULL)
        return E_INVALIDARG;

    oldACL = *ppAcl;

    HRESULT hr = GetPrincipalSID(pszPrincipal, &principalSID);
    if (FAILED(hr))
        return hr;

    aclSizeInfo.AclBytesInUse = 0;
    if (*ppAcl != NULL &&
        !GetAclInformation(oldACL, (LPVOID)&aclSizeInfo, sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
        free(principalSID);
        return AtlHresultFromLastError();
    }

    aclSize = aclSizeInfo.AclBytesInUse + sizeof(ACL) +        // size of original ACL
        sizeof(ACCESS_DENIED_ACE) +                                         // size of ACE
        GetLengthSid(principalSID) -                                         // Actual size of SID
        sizeof(DWORD);                                                                        // subtract size of placeholder variable 
                                                                                              // for SID in ACCESS_*_ACE structure

    newACL = (PACL)malloc(aclSize);
    if (newACL == NULL) {
        free(principalSID);
        return E_OUTOFMEMORY;
    }

    if (!InitializeAcl(newACL, aclSize, ACL_REVISION)) {
        hr = AtlHresultFromLastError();
        free(newACL);
        free(principalSID);
        return hr;
    }

    if (!AddAccessDeniedAce(newACL, ACL_REVISION2, dwAccessMask, principalSID)) {
        hr = AtlHresultFromLastError();
        free(newACL);
        free(principalSID);
        return hr;
    }

    hr = CopyACL(newACL, oldACL);
    if (FAILED(hr)) {
        free(newACL);
        free(principalSID);
        return hr;
    }

    *ppAcl = newACL;

    if (oldACL != NULL)
        free(oldACL);
    free(principalSID);
    return S_OK;
}


inline HRESULT CSecurityDescriptor::AddAccessAllowedACEToACL(PACL* ppAcl, LPCTSTR pszPrincipal, DWORD dwAccessMask)
{
    ACL_SIZE_INFORMATION aclSizeInfo;
    int aclSize;
    PSID principalSID;
    PACL oldACL, newACL = NULL;

    if (ppAcl == NULL)
        return E_POINTER;

    if (pszPrincipal == NULL)
        return E_INVALIDARG;

    oldACL = *ppAcl;

    HRESULT hr = GetPrincipalSID(pszPrincipal, &principalSID);
    if (FAILED(hr))
        return hr;

    aclSizeInfo.AclBytesInUse = 0;
    if (*ppAcl != NULL &&
        !GetAclInformation(oldACL, (LPVOID)&aclSizeInfo, sizeof(ACL_SIZE_INFORMATION), AclSizeInformation))
        return AtlHresultFromLastError();

    aclSize = aclSizeInfo.AclBytesInUse + sizeof(ACL) + // size of original ACL
        sizeof(ACCESS_ALLOWED_ACE) +                                         // size of ACE
        GetLengthSid(principalSID) -                                         // Actual size of SID
        sizeof(DWORD);                                                                        // subtract size of placeholder variable 
                                                                                              // for SID in ACCESS_*_ACE structure

    newACL = (PACL)malloc(aclSize);
    if (newACL == NULL) {
        free(principalSID);
        return E_OUTOFMEMORY;
    }

    if (!InitializeAcl(newACL, aclSize, ACL_REVISION)) {
        hr = AtlHresultFromLastError();
        free(newACL);
        free(principalSID);
        return hr;
    }

    if (!AddAccessAllowedAce(newACL, ACL_REVISION2, dwAccessMask, principalSID)) {
        hr = AtlHresultFromLastError();
        free(newACL);
        free(principalSID);
        return hr;
    }

    hr = CopyACL(newACL, oldACL);
    if (FAILED(hr)) {
        free(newACL);
        free(principalSID);
        return hr;
    }

    *ppAcl = newACL;

    if (oldACL != NULL)
        free(oldACL);
    free(principalSID);
    return S_OK;
}

inline HRESULT CSecurityDescriptor::RemovePrincipalFromACL(PACL pAcl, LPCTSTR pszPrincipal)
{
    if (pAcl == NULL || pszPrincipal == NULL)
        return E_INVALIDARG;

    PSID principalSID;
    HRESULT hr = GetPrincipalSID(pszPrincipal, &principalSID);
    if (FAILED(hr))
        return hr;

    ACL_SIZE_INFORMATION aclSizeInfo;
    if (!GetAclInformation(pAcl, (LPVOID)&aclSizeInfo, (DWORD)sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
        hr = AtlHresultFromLastError();
        aclSizeInfo.AceCount = 0;
    }

    for (ULONG i = aclSizeInfo.AceCount; i > 0; i--) {
        ULONG uIndex = i - 1;
        LPVOID ace;
        if (!GetAce(pAcl, uIndex, &ace)) {
            hr = AtlHresultFromLastError();
            break;
        }

        ACE_HEADER* aceHeader = (ACE_HEADER*)ace;

        if (aceHeader->AceType == ACCESS_ALLOWED_ACE_TYPE) {
            ACCESS_ALLOWED_ACE* accessAllowedAce = (ACCESS_ALLOWED_ACE*)ace;
            if (EqualSid(principalSID, (PSID)&accessAllowedAce->SidStart)) {
                DeleteAce(pAcl, uIndex);
            }
        } else if (aceHeader->AceType == ACCESS_DENIED_ACE_TYPE) {
            ACCESS_DENIED_ACE* accessDeniedAce = (ACCESS_DENIED_ACE*)ace;
            if (EqualSid(principalSID, (PSID)&accessDeniedAce->SidStart)) {
                DeleteAce(pAcl, uIndex);
            }
        } else if (aceHeader->AceType == SYSTEM_AUDIT_ACE_TYPE) {
            SYSTEM_AUDIT_ACE* systemAuditAce = (SYSTEM_AUDIT_ACE*)ace;
            if (EqualSid(principalSID, (PSID)&systemAuditAce->SidStart)) {
                DeleteAce(pAcl, uIndex);
            }
        }
    }
    free(principalSID);
    return hr;
}

inline HRESULT CSecurityDescriptor::SetPrivilege(LPCTSTR privilege, BOOL bEnable, HANDLE hToken)
{
    HRESULT hr;
    TOKEN_PRIVILEGES tpPrevious;
    TOKEN_PRIVILEGES tp;
    DWORD  cbPrevious = sizeof(TOKEN_PRIVILEGES);
    LUID   luid;
    HANDLE hTokenUsed;

    // if no token specified open process token
    if (hToken == 0) {
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hTokenUsed)) {
            hr = HRESULT_FROM_WIN32(GetLastError());
            ATLASSERT(FALSE);
            return hr;
        }
    } else
        hTokenUsed = hToken;

    if (!LookupPrivilegeValue(NULL, privilege, &luid)) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        if (hToken == 0)
            CloseHandle(hTokenUsed);
        return hr;
    }

    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    tp.Privileges[0].Attributes = 0;

    if (!AdjustTokenPrivileges(hTokenUsed, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &tpPrevious, &cbPrevious)) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        if (hToken == 0)
            CloseHandle(hTokenUsed);
        return hr;
    }

    tpPrevious.PrivilegeCount = 1;
    tpPrevious.Privileges[0].Luid = luid;

    if (bEnable)
        tpPrevious.Privileges[0].Attributes |= (SE_PRIVILEGE_ENABLED);
    else
        tpPrevious.Privileges[0].Attributes ^= (SE_PRIVILEGE_ENABLED & tpPrevious.Privileges[0].Attributes);

    if (!AdjustTokenPrivileges(hTokenUsed, FALSE, &tpPrevious, cbPrevious, NULL, NULL)) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        ATLASSERT(FALSE);
        if (hToken == 0)
            CloseHandle(hTokenUsed);
        return hr;
    }
    return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
// COM Objects

#define DECLARE_PROTECT_FINAL_CONSTRUCT()\
        void InternalFinalConstructAddRef() {InternalAddRef();}\
        void InternalFinalConstructRelease() {InternalRelease();}

template <class T1>
class CComCreator {
public:
    static HRESULT WINAPI CreateInstance(void* pv, REFIID riid, LPVOID* ppv)
    {
        _ATL_VALIDATE_OUT_POINTER(ppv);
        HRESULT hRes = E_OUTOFMEMORY;
        T1* p = NULL;
        ATLTRY(p = new T1(pv))
            if (p != NULL) {
                p->SetVoid(pv);
                p->InternalFinalConstructAddRef();
                hRes = p->FinalConstruct();
                p->InternalFinalConstructRelease();
                if (hRes == S_OK)
                    hRes = p->QueryInterface(riid, ppv);
                if (hRes != S_OK)
                    delete p;
            }
        return hRes;
    }
};

template <class T1>
class CComInternalCreator {
public:
    static HRESULT WINAPI CreateInstance(void* pv, REFIID riid, LPVOID* ppv)
    {
        _ATL_VALIDATE_OUT_POINTER(ppv);
        HRESULT hRes = E_OUTOFMEMORY;
        T1* p = NULL;
        ATLTRY(p = new T1(pv))
            if (p != NULL) {
                p->SetVoid(pv);
                p->InternalFinalConstructAddRef();
                hRes = p->FinalConstruct();
                p->InternalFinalConstructRelease();
                if (hRes == S_OK)
                    hRes = p->_InternalQueryInterface(riid, ppv);
                if (hRes != S_OK)
                    delete p;
            }
        return hRes;
    }
};

template <HRESULT hr>
class CComFailCreator {
public:
    static HRESULT WINAPI CreateInstance(void*, REFIID, LPVOID* ppv)
    {
        _ATL_VALIDATE_OUT_POINTER(ppv);
        return hr;
    }
};

template <class T1, class T2>
class CComCreator2 {
public:
    static HRESULT WINAPI CreateInstance(void* pv, REFIID riid, LPVOID* ppv)
    {
        // Assert Only. Validation done in functions called from here
        ATLASSERT(ppv != NULL && *ppv == NULL);
        return (pv == NULL) ?
            T1::CreateInstance(NULL, riid, ppv) :
            T2::CreateInstance(pv, riid, ppv);
    }
};

#define DECLARE_NOT_AGGREGATABLE(x) public:\
        typedef CComCreator2< CComCreator< CComObject< x > >, CComFailCreator<CLASS_E_NOAGGREGATION> > _CreatorClass;
#define DECLARE_AGGREGATABLE(x) public:\
        typedef CComCreator2< CComCreator< CComObject< x > >, CComCreator< CComAggObject< x > > > _CreatorClass;
#define DECLARE_ONLY_AGGREGATABLE(x) public:\
        typedef CComCreator2< CComFailCreator<E_FAIL>, CComCreator< CComAggObject< x > > > _CreatorClass;
#define DECLARE_POLY_AGGREGATABLE(x) public:\
        typedef CComCreator< CComPolyObject< x > > _CreatorClass;

struct _ATL_CREATORDATA {
    _ATL_CREATORFUNC* pFunc;
};

template <class Creator>
class _CComCreatorData {
public:
    static _ATL_CREATORDATA data;
};

template <class Creator>
_ATL_CREATORDATA _CComCreatorData<Creator>::data = { Creator::CreateInstance };

struct _ATL_CACHEDATA {
    DWORD dwOffsetVar;
    _ATL_CREATORFUNC* pFunc;
};

template <class Creator, DWORD dwVar>
class _CComCacheData {
public:
    static _ATL_CACHEDATA data;
};

template <class Creator, DWORD dwVar>
_ATL_CACHEDATA _CComCacheData<Creator, dwVar>::data = { dwVar, Creator::CreateInstance };

struct _ATL_CHAINDATA {
    DWORD_PTR dwOffset;
    const _ATL_INTMAP_ENTRY* (WINAPI* pFunc)();
};

template <class base, class derived>
class _CComChainData {
public:
    static _ATL_CHAINDATA data;
};

template <class base, class derived>
_ATL_CHAINDATA _CComChainData<base, derived>::data =
{ offsetofclass(base, derived), base::_GetEntries };

template <class T, const CLSID* pclsid>
class CComAggregateCreator {
public:
    static HRESULT WINAPI CreateInstance(void* pv, REFIID/*riid*/, LPVOID* ppv)
    {
        // Real check will be made in the call to CoCreateInstance
        ATLASSERT(ppv != NULL && *ppv == NULL);

        ATLASSERT(pv != NULL);
        if (pv == NULL)
            return E_INVALIDARG;

        T* p = (T*)pv;
        // Add the following line to your object if you get a message about
        // GetControllingUnknown() being undefined
        // DECLARE_GET_CONTROLLING_UNKNOWN()
        return CoCreateInstance(*pclsid, p->GetControllingUnknown(), CLSCTX_INPROC, IID_IUnknown, ppv);
    }
};

#ifdef _ATL_DEBUG
#define DEBUG_QI_ENTRY(x) \
                {NULL, \
                (DWORD_PTR)_T(#x), \
                (_ATL_CREATORARGFUNC*)0},
#else
#define DEBUG_QI_ENTRY(x)
#endif //_ATL_DEBUG

#ifdef _ATL_DEBUG_INTERFACES
#define _ATL_DECLARE_GET_UNKNOWN(x)\
        IUnknown* GetUnknown() \
        { \
                IUnknown* p; \
                _Module.AddNonAddRefThunk(_GetRawUnknown(), _T(#x), &p); \
                return p; \
        }
#else
#define _ATL_DECLARE_GET_UNKNOWN(x) IUnknown* GetUnknown() {return _GetRawUnknown();}
#endif

//If you get a message that FinalConstruct is ambiguous then you need to
// override it in your class and call each base class' version of this
#define BEGIN_COM_MAP(x) public: \
        typedef x _ComMapClass; \
        static HRESULT WINAPI _Cache(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)\
        {\
                _ComMapClass* p = (_ComMapClass*)pv;\
                p->Lock();\
                HRESULT hRes = E_FAIL; \
                __try \
                { \
                        hRes = CComObjectRootBase::_Cache(pv, iid, ppvObject, dw);\
                } \
                __finally \
                { \
                        p->Unlock();\
                } \
                return hRes;\
        }\
        IUnknown* _GetRawUnknown() \
        { ATLASSERT(_GetEntries()[0].pFunc == _ATL_SIMPLEMAPENTRY); return (IUnknown*)((DWORD_PTR)this+_GetEntries()->dw); } \
        _ATL_DECLARE_GET_UNKNOWN(x)\
        HRESULT _InternalQueryInterface(REFIID iid, void** ppvObject) \
        { return Base::InternalQueryInterface(this, _GetEntries(), iid, ppvObject); } \
        const static _ATL_INTMAP_ENTRY* WINAPI _GetEntries() { \
        static const _ATL_INTMAP_ENTRY _entries[] = { DEBUG_QI_ENTRY(x)

#define DECLARE_GET_CONTROLLING_UNKNOWN() public:\
        virtual IUnknown* GetControllingUnknown() {return GetUnknown();}

#ifndef _ATL_NO_UUIDOF
#define _ATL_IIDOF(x) __uuidof(x)
#else
#define _ATL_IIDOF(x) IID_##x
#endif

#define COM_INTERFACE_ENTRY_BREAK(x)\
        {&_ATL_IIDOF(x), \
        NULL, \
        _Break},

#define COM_INTERFACE_ENTRY_NOINTERFACE(x)\
        {&_ATL_IIDOF(x), \
        NULL, \
        _NoInterface},

#define COM_INTERFACE_ENTRY(x)\
        {&_ATL_IIDOF(x), \
        offsetofclass(x, _ComMapClass), \
        _ATL_SIMPLEMAPENTRY},

#define COM_INTERFACE_ENTRY_IID(iid, x)\
        {&iid,\
        offsetofclass(x, _ComMapClass),\
        _ATL_SIMPLEMAPENTRY},

// The impl macros are now obsolete
#define COM_INTERFACE_ENTRY_IMPL(x)\
        COM_INTERFACE_ENTRY_IID(_ATL_IIDOF(x), x##Impl<_ComMapClass>)

#define COM_INTERFACE_ENTRY_IMPL_IID(iid, x)\
        COM_INTERFACE_ENTRY_IID(iid, x##Impl<_ComMapClass>)
//

#define COM_INTERFACE_ENTRY2(x, x2)\
        {&_ATL_IIDOF(x),\
        (DWORD_PTR)((x*)(x2*)((_ComMapClass*)8))-8,\
        _ATL_SIMPLEMAPENTRY},

#define COM_INTERFACE_ENTRY2_IID(iid, x, x2)\
        {&iid,\
        (DWORD_PTR)((x*)(x2*)((_ComMapClass*)8))-8,\
        _ATL_SIMPLEMAPENTRY},

#define COM_INTERFACE_ENTRY_FUNC(iid, dw, func)\
        {&iid, \
        dw, \
        func},

#define COM_INTERFACE_ENTRY_FUNC_BLIND(dw, func)\
        {NULL, \
        dw, \
        func},

#define COM_INTERFACE_ENTRY_TEAR_OFF(iid, x)\
        {&iid,\
        (DWORD_PTR)&_CComCreatorData<\
                CComInternalCreator< CComTearOffObject< x > >\
                >::data,\
        _Creator},

#define COM_INTERFACE_ENTRY_CACHED_TEAR_OFF(iid, x, punk)\
        {&iid,\
        (DWORD_PTR)&_CComCacheData<\
                CComCreator< CComCachedTearOffObject< x > >,\
                offsetof(_ComMapClass, punk)\
                >::data,\
        _Cache},

#define COM_INTERFACE_ENTRY_AGGREGATE(iid, punk)\
        {&iid,\
        offsetof(_ComMapClass, punk),\
        _Delegate},

#define COM_INTERFACE_ENTRY_AGGREGATE_BLIND(punk)\
        {NULL,\
        offsetof(_ComMapClass, punk),\
        _Delegate},

#define COM_INTERFACE_ENTRY_AUTOAGGREGATE(iid, punk, clsid)\
        {&iid,\
        (DWORD_PTR)&_CComCacheData<\
                CComAggregateCreator<_ComMapClass, &clsid>,\
                offsetof(_ComMapClass, punk)\
                >::data,\
        _Cache},

#define COM_INTERFACE_ENTRY_AUTOAGGREGATE_BLIND(punk, clsid)\
        {NULL,\
        (DWORD_PTR)&_CComCacheData<\
                CComAggregateCreator<_ComMapClass, &clsid>,\
                offsetof(_ComMapClass, punk)\
                >::data,\
        _Cache},

#define COM_INTERFACE_ENTRY_CHAIN(classname)\
        {NULL,\
        (DWORD_PTR)&_CComChainData<classname, _ComMapClass>::data,\
        _Chain},

#ifdef _ATL_DEBUG
#define END_COM_MAP() {NULL, 0, 0}}; return &_entries[1];} \
        virtual ULONG STDMETHODCALLTYPE AddRef( void) = 0; \
        virtual ULONG STDMETHODCALLTYPE Release( void) = 0; \
        STDMETHOD(QueryInterface)(REFIID, void**) = 0;
#else
#define END_COM_MAP() {NULL, 0, 0}}; return _entries;} \
        virtual ULONG STDMETHODCALLTYPE AddRef( void) = 0; \
        virtual ULONG STDMETHODCALLTYPE Release( void) = 0; \
        STDMETHOD(QueryInterface)(REFIID, void**) = 0;
#endif // _ATL_DEBUG

#define BEGIN_CATEGORY_MAP(x)\
   static const struct _ATL_CATMAP_ENTRY* GetCategoryMap() {\
   static const struct _ATL_CATMAP_ENTRY pMap[] = {
#define IMPLEMENTED_CATEGORY( catid ) { _ATL_CATMAP_ENTRY_IMPLEMENTED, &catid },
#define REQUIRED_CATEGORY( catid ) { _ATL_CATMAP_ENTRY_REQUIRED, &catid },
#define END_CATEGORY_MAP()\
   { _ATL_CATMAP_ENTRY_END, NULL } };\
   return( pMap ); }

#define BEGIN_OBJECT_MAP(x) static _ATL_OBJMAP_ENTRY x[] = {
#define END_OBJECT_MAP()   {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}};
#define OBJECT_ENTRY(clsid, class) {&clsid, class::UpdateRegistry, class::_ClassFactoryCreatorClass::CreateInstance, class::_CreatorClass::CreateInstance, NULL, 0, class::GetObjectDescription, class::GetCategoryMap, class::ObjectMain },
#define OBJECT_ENTRY_NON_CREATEABLE(class) {&CLSID_NULL, class::UpdateRegistry, NULL, NULL, NULL, 0, NULL, class::GetCategoryMap, class::ObjectMain },

#ifdef _ATL_DEBUG
extern HRESULT WINAPI AtlDumpIID(REFIID iid, LPCTSTR pszClassName, HRESULT hr);
#endif // _ATL_DEBUG


// the functions in this class don't need to be virtual because
// they are called from CComObject
class CComObjectRootBase {
public:
    CComObjectRootBase()
    {
        m_dwRef = 0L;
    }
    HRESULT FinalConstruct()
    {
        return S_OK;
    }
    // For library initialization only
    HRESULT _AtlFinalConstruct()
    {
        return S_OK;
    }
    void FinalRelease() {}
    void _AtlFinalRelease() {}

    //ObjectMain is called during Module::Init and Module::Term
    static void WINAPI ObjectMain(bool /* bStarting */) {}

    static HRESULT WINAPI InternalQueryInterface(void* pThis,
        const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject)
    {
        ATLASSERT(pThis != NULL);
        // First entry in the com map should be a simple map entry
        ATLASSERT(pEntries->pFunc == _ATL_SIMPLEMAPENTRY);
#if defined(_ATL_DEBUG_INTERFACES) || defined(_ATL_DEBUG_QI)
        LPCTSTR pszClassName = (LPCTSTR)pEntries[-1].dw;
#endif // _ATL_DEBUG_INTERFACES
        HRESULT hRes = AtlInternalQueryInterface(pThis, pEntries, iid, ppvObject);
#ifdef _ATL_DEBUG_INTERFACES
        _Module.AddThunk((IUnknown**)ppvObject, pszClassName, iid);
#endif // _ATL_DEBUG_INTERFACES
        return _ATLDUMPIID(iid, pszClassName, hRes);
    }

    //Outer funcs
    ULONG OuterAddRef()
    {
        return m_pOuterUnknown->AddRef();
    }
    ULONG OuterRelease()
    {
        return m_pOuterUnknown->Release();
    }
    HRESULT OuterQueryInterface(REFIID iid, void** ppvObject)
    {
        return m_pOuterUnknown->QueryInterface(iid, ppvObject);
    }

    void SetVoid(void*) {}
    void InternalFinalConstructAddRef() {}
    void InternalFinalConstructRelease()
    {
        ATLASSERT(m_dwRef == 0);
    }
    // If this assert occurs, your object has probably been deleted
    // Try using DECLARE_PROTECT_FINAL_CONSTRUCT()


    static HRESULT WINAPI _Break(void* /* pv */, REFIID iid, void** /* ppvObject */, DWORD_PTR /* dw */)
    {
        iid;
        _ATLDUMPIID(iid, _T("Break due to QI for interface "), S_OK);
        DebugBreak();
        return S_FALSE;
    }
    static HRESULT WINAPI _NoInterface(void* /* pv */, REFIID /* iid */, void** /* ppvObject */, DWORD_PTR /* dw */)
    {
        return E_NOINTERFACE;
    }
    static HRESULT WINAPI _Creator(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)
    {
        _ATL_CREATORDATA* pcd = (_ATL_CREATORDATA*)dw;
        return pcd->pFunc(pv, iid, ppvObject);
    }
    static HRESULT WINAPI _Delegate(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)
    {
        HRESULT hRes = E_NOINTERFACE;
        IUnknown* p = *(IUnknown**)((DWORD_PTR)pv + dw);
        if (p != NULL)
            hRes = p->QueryInterface(iid, ppvObject);
        return hRes;
    }
    static HRESULT WINAPI _Chain(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)
    {
        _ATL_CHAINDATA* pcd = (_ATL_CHAINDATA*)dw;
        void* p = (void*)((DWORD_PTR)pv + pcd->dwOffset);
        return InternalQueryInterface(p, pcd->pFunc(), iid, ppvObject);
    }
    static HRESULT WINAPI _Cache(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)
    {
        HRESULT hRes = E_NOINTERFACE;
        _ATL_CACHEDATA* pcd = (_ATL_CACHEDATA*)dw;
        IUnknown** pp = (IUnknown**)((DWORD_PTR)pv + pcd->dwOffsetVar);
        if (*pp == NULL)
            hRes = pcd->pFunc(pv, IID_IUnknown, (void**)pp);
        if (*pp != NULL)
            hRes = (*pp)->QueryInterface(iid, ppvObject);
        return hRes;
    }

    union {
        long m_dwRef;
        IUnknown* m_pOuterUnknown;
    };
};

//foward declaration
template <class ThreadModel>
class CComObjectRootEx;

template <class ThreadModel>
class CComObjectLockT {
public:
    CComObjectLockT(CComObjectRootEx<ThreadModel>* p)
    {
        if (p)
            p->Lock();
        m_p = p;
    }

    ~CComObjectLockT()
    {
        if (m_p)
            m_p->Unlock();
    }
    CComObjectRootEx<ThreadModel>* m_p;
};

template <> class CComObjectLockT<CComSingleThreadModel>;

template <class ThreadModel>
class CComObjectRootEx : public CComObjectRootBase {
public:
    typedef ThreadModel _ThreadModel;
    typename typedef _ThreadModel::AutoCriticalSection _CritSec;
    typedef CComObjectLockT<_ThreadModel> ObjectLock;

    ULONG InternalAddRef()
    {
        ATLASSERT(m_dwRef != -1L);
        return _ThreadModel::Increment(&m_dwRef);
    }
    ULONG InternalRelease()
    {
        ATLASSERT(m_dwRef > 0);
        return _ThreadModel::Decrement(&m_dwRef);
    }

    void Lock() { m_critsec.Lock(); }
    void Unlock() { m_critsec.Unlock(); }
private:
    _CritSec m_critsec;
};

template <>
class CComObjectRootEx<CComSingleThreadModel> : public CComObjectRootBase {
public:
    typedef CComSingleThreadModel _ThreadModel;
    typedef _ThreadModel::AutoCriticalSection _CritSec;
    typedef CComObjectLockT<_ThreadModel> ObjectLock;

    ULONG InternalAddRef()
    {
        ATLASSERT(m_dwRef != -1L);
        return _ThreadModel::Increment(&m_dwRef);
    }
    ULONG InternalRelease()
    {
        return _ThreadModel::Decrement(&m_dwRef);
    }

    void Lock() {}
    void Unlock() {}
};

template <>
class CComObjectLockT<CComSingleThreadModel> {
public:
    CComObjectLockT(CComObjectRootEx<CComSingleThreadModel>*) {}
    ~CComObjectLockT() {}
};

typedef CComObjectRootEx<CComObjectThreadModel> CComObjectRoot;

#if defined(_WINDLL) | defined(_USRDLL)
#define DECLARE_CLASSFACTORY_EX(cf) typedef CComCreator< CComObjectCached< cf > > _ClassFactoryCreatorClass;
#else
// don't let class factory refcount influence lock count
#define DECLARE_CLASSFACTORY_EX(cf) typedef CComCreator< CComObjectNoLock< cf > > _ClassFactoryCreatorClass;
#endif
#define DECLARE_CLASSFACTORY() DECLARE_CLASSFACTORY_EX(CComClassFactory)
#define DECLARE_CLASSFACTORY2(lic) DECLARE_CLASSFACTORY_EX(CComClassFactory2<lic>)
#define DECLARE_CLASSFACTORY_AUTO_THREAD() DECLARE_CLASSFACTORY_EX(CComClassFactoryAutoThread)
#define DECLARE_CLASSFACTORY_SINGLETON(obj) DECLARE_CLASSFACTORY_EX(CComClassFactorySingleton<obj>)

#define DECLARE_OBJECT_DESCRIPTION(x)\
        static LPCTSTR WINAPI GetObjectDescription()\
        {\
                return _T(x);\
        }

#define DECLARE_NO_REGISTRY()\
        static HRESULT WINAPI UpdateRegistry(BOOL /*bRegister*/)\
        {return S_OK;}

#define DECLARE_REGISTRY(class, pid, vpid, nid, flags)\
        static HRESULT WINAPI UpdateRegistry(BOOL bRegister)\
        {\
                return _Module.UpdateRegistryClass(GetObjectCLSID(), pid, vpid, nid,\
                        flags, bRegister);\
        }

#define DECLARE_REGISTRY_RESOURCE(x)\
        static HRESULT WINAPI UpdateRegistry(BOOL bRegister)\
        {\
        return _Module.UpdateRegistryFromResource(_T(#x), bRegister);\
        }

#define DECLARE_REGISTRY_RESOURCEID(x)\
        static HRESULT WINAPI UpdateRegistry(BOOL bRegister)\
        {\
        return _Module.UpdateRegistryFromResource(x, bRegister);\
        }

//DECLARE_STATIC_* provided for backward compatibility
#ifdef _ATL_STATIC_REGISTRY
#define DECLARE_STATIC_REGISTRY_RESOURCE(x) DECLARE_REGISTRY_RESOURCE(x)
#define DECLARE_STATIC_REGISTRY_RESOURCEID(x) DECLARE_REGISTRY_RESOURCEID(x)
#endif //_ATL_STATIC_REGISTRY

template<class Base> class CComObject; // fwd decl

template <class Owner, class ThreadModel = CComObjectThreadModel>
class CComTearOffObjectBase : public CComObjectRootEx<ThreadModel> {
public:
    typedef Owner _OwnerClass;
    CComObject<Owner>* m_pOwner;
    CComTearOffObjectBase() { m_pOwner = NULL; }
};

//Base is the user's class that derives from CComObjectRoot and whatever
//interfaces the user wants to support on the object
template <class Base>
class CComObject : public Base {
public:
    typedef Base _BaseClass;
    //typedef CComObjectRootBase _BaseClass;
    CComObject(void* = NULL)
    {
        _Module.Lock();
    }
    // Set refcount to 1 to protect destruction
    ~CComObject()
    {
        Base::m_dwRef = 1L;
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
        _Module.Unlock();
    }
    //If InternalAddRef or InternalRelease is undefined then your class
    //doesn't derive from CComObjectRoot
    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    //if _InternalQueryInterface is undefined then you forgot BEGIN_COM_MAP
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        return Base::_InternalQueryInterface(iid, ppvObject);
    }
    template <class Q>
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)
    {
        return Base::QueryInterface(__uuidof(Q), (void**)pp);
    }

    static HRESULT WINAPI CreateInstance(CComObject<Base>** pp);
};

template <class Base>
HRESULT WINAPI CComObject<Base>::CreateInstance(CComObject<Base>** pp)
{
    _ATL_VALIDATE_OUT_POINTER(pp);

    HRESULT hRes = E_OUTOFMEMORY;
    CComObject<Base>* p = NULL;
    ATLTRY(p = new CComObject<Base>())
        if (p != NULL) {
            p->SetVoid(NULL);
            p->InternalFinalConstructAddRef();
            hRes = p->FinalConstruct();
            p->InternalFinalConstructRelease();
            if (hRes != S_OK) {
                delete p;
                p = NULL;
            }
        }
    *pp = p;
    return hRes;
}

//Base is the user's class that derives from CComObjectRoot and whatever
//interfaces the user wants to support on the object
// CComObjectCached is used primarily for class factories in DLL's
// but it is useful anytime you want to cache an object
template <class Base>
class CComObjectCached : public Base {
public:
    typedef Base _BaseClass;
    CComObjectCached(void* = NULL) {}
    // Set refcount to 1 to protect destruction
    ~CComObjectCached()
    {
        Base::m_dwRef = 1L;
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
    }
    //If InternalAddRef or InternalRelease is undefined then your class
    //doesn't derive from CComObjectRoot
    STDMETHOD_(ULONG, AddRef)()
    {
        m_csCached.Lock();
        ULONG l = Base::InternalAddRef();
        if (Base::m_dwRef == 2)
            _Module.Lock();
        m_csCached.Unlock();
        return l;
    }
    STDMETHOD_(ULONG, Release)()
    {
        m_csCached.Lock();
        Base::InternalRelease();
        ULONG l = Base::m_dwRef;
        m_csCached.Unlock();
        if (l == 0)
            delete this;
        else if (l == 1)
            _Module.Unlock();
        return l;
    }
    //if _InternalQueryInterface is undefined then you forgot BEGIN_COM_MAP
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        return Base::_InternalQueryInterface(iid, ppvObject);
    }
    CComGlobalsThreadModel::AutoCriticalSection m_csCached;
};

//Base is the user's class that derives from CComObjectRoot and whatever
//interfaces the user wants to support on the object
template <class Base>
class CComObjectNoLock : public Base {
public:
    typedef Base _BaseClass;
    CComObjectNoLock(void* = NULL) {}
    // Set refcount to 1 to protect destruction
    ~CComObjectNoLock()
    {
        Base::m_dwRef = 1L;
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
    }

    //If InternalAddRef or InternalRelease is undefined then your class
    //doesn't derive from CComObjectRoot
    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    //if _InternalQueryInterface is undefined then you forgot BEGIN_COM_MAP
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        return Base::_InternalQueryInterface(iid, ppvObject);
    }
};

// It is possible for Base not to derive from CComObjectRoot
// However, you will need to provide FinalConstruct and InternalQueryInterface
template <class Base>
class CComObjectGlobal : public Base {
public:
    typedef Base _BaseClass;
    CComObjectGlobal(void* = NULL) { m_hResFinalConstruct = Base::FinalConstruct(); }
    ~CComObjectGlobal()
    {
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
    }

    STDMETHOD_(ULONG, AddRef)() { return _Module.Lock(); }
    STDMETHOD_(ULONG, Release)() { return _Module.Unlock(); }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        return Base::_InternalQueryInterface(iid, ppvObject);
    }
    HRESULT m_hResFinalConstruct;
};

// It is possible for Base not to derive from CComObjectRoot
// However, you will need to provide FinalConstruct and InternalQueryInterface
template <class Base>
class CComObjectStack : public Base {
public:
    typedef Base _BaseClass;
    CComObjectStack(void* = NULL) { m_hResFinalConstruct = Base::FinalConstruct(); }
    ~CComObjectStack()
    {
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
    }


    STDMETHOD_(ULONG, AddRef)() { ATLASSERT(FALSE); return 0; }
    STDMETHOD_(ULONG, Release)() { ATLASSERT(FALSE); return 0; }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        ATLASSERT(FALSE); return E_NOINTERFACE;
    }
    HRESULT m_hResFinalConstruct;
};

template <class Base> //Base must be derived from CComObjectRoot
class CComContainedObject : public Base {
public:
    typedef Base _BaseClass;
    CComContainedObject(void* pv) { Base::m_pOuterUnknown = (IUnknown*)pv; }
#ifdef _ATL_DEBUG_INTERFACES
    ~CComContainedObject()
    {
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
        _Module.DeleteNonAddRefThunk(m_pOuterUnknown);
    }
#endif

    STDMETHOD_(ULONG, AddRef)() { return Base::OuterAddRef(); }
    STDMETHOD_(ULONG, Release)() { return Base::OuterRelease(); }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        HRESULT hr = Base::OuterQueryInterface(iid, ppvObject);
        if (FAILED(hr) && Base::_GetRawUnknown() != Base::m_pOuterUnknown)
            hr = Base::_InternalQueryInterface(iid, ppvObject);
        return hr;
    }
    template <class Q>
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)
    {
        return QueryInterface(__uuidof(Q), (void**)pp);
    }
    //GetControllingUnknown may be virtual if the Base class has declared
    //DECLARE_GET_CONTROLLING_UNKNOWN()
    IUnknown* GetControllingUnknown()
    {
#ifdef _ATL_DEBUG_INTERFACES
        IUnknown* p;
        _Module.AddNonAddRefThunk(m_pOuterUnknown, _T("CComContainedObject"), &p);
        return p;
#else
        return Base::m_pOuterUnknown;
#endif
    }
};

//contained is the user's class that derives from CComObjectRoot and whatever
//interfaces the user wants to support on the object
template <class contained>
class CComAggObject :
    public IUnknown,
    public CComObjectRootEx< typename contained::_ThreadModel::ThreadModelNoCS > {
public:
    typedef contained _BaseClass;
    typedef CComObjectRootEx< typename contained::_ThreadModel::ThreadModelNoCS > Base;
    CComAggObject(void* pv) : m_contained(pv)
    {
        _Module.Lock();
    }
    //If you get a message that this call is ambiguous then you need to
    // override it in your class and call each base class' version of this
    HRESULT FinalConstruct()
    {
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalConstruct();
        return m_contained.FinalConstruct();
    }
    void FinalRelease()
    {
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalRelease();
        m_contained.FinalRelease();
    }
    // Set refcount to 1 to protect destruction
    ~CComAggObject()
    {
        Base::m_dwRef = 1L;
        FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(this);
#endif
        _Module.Unlock();
    }

    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        HRESULT hRes = S_OK;
        if (InlineIsEqualUnknown(iid)) {
            if (ppvObject == NULL)
                return E_POINTER;
            *ppvObject = (void*)(IUnknown*)this;
            AddRef();
#ifdef _ATL_DEBUG_INTERFACES
            _Module.AddThunk((IUnknown**)ppvObject, (LPCTSTR)contained::_GetEntries()[-1].dw, iid);
#endif // _ATL_DEBUG_INTERFACES
        } else
            hRes = m_contained._InternalQueryInterface(iid, ppvObject);
        return hRes;
    }
    template <class Q>
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)
    {
        return QueryInterface(__uuidof(Q), (void**)pp);
    }
    static HRESULT WINAPI CreateInstance(LPUNKNOWN pUnkOuter, CComAggObject<contained>** pp)
    {
        _ATL_VALIDATE_OUT_POINTER(pp);

        HRESULT hRes = E_OUTOFMEMORY;
        CComAggObject<contained>* p = NULL;
        ATLTRY(p = new CComAggObject<contained>(pUnkOuter))
            if (p != NULL) {
                p->SetVoid(NULL);
                p->InternalFinalConstructAddRef();
                hRes = p->FinalConstruct();
                p->InternalFinalConstructRelease();
                if (hRes != S_OK) {
                    delete p;
                    p = NULL;
                }
            }
        *pp = p;
        return hRes;
    }

    CComContainedObject<contained> m_contained;
};

///////////////////////////////////////////////////////////////////////////////
// CComPolyObject can be either aggregated or not aggregated

template <class contained>
class CComPolyObject :
    public IUnknown,
    public CComObjectRootEx< typename contained::_ThreadModel::ThreadModelNoCS > {
public:
    typedef contained _BaseClass;
    typedef CComObjectRootEx< typename contained::_ThreadModel::ThreadModelNoCS > Base;
    CComPolyObject(void* pv) : m_contained(pv ? pv : this)
    {
        _Module.Lock();
    }
    //If you get a message that this call is ambiguous then you need to
    // override it in your class and call each base class' version of this
    HRESULT FinalConstruct()
    {
        Base::InternalAddRef();
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalConstruct();
        HRESULT hr = m_contained.FinalConstruct();
        Base::InternalRelease();
        return hr;
    }
    void FinalRelease()
    {
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalRelease();
        m_contained.FinalRelease();
    }
    // Set refcount to 1 to protect destruction
    ~CComPolyObject()
    {
        Base::m_dwRef = 1L;
        FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(this);
#endif
        _Module.Unlock();
    }

    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        if (ppvObject == NULL)
            return E_POINTER;
        *ppvObject = NULL;

        HRESULT hRes = S_OK;
        if (InlineIsEqualUnknown(iid)) {
            *ppvObject = (void*)(IUnknown*)this;
            AddRef();
#ifdef _ATL_DEBUG_INTERFACES
            _Module.AddThunk((IUnknown**)ppvObject, (LPCTSTR)contained::_GetEntries()[-1].dw, iid);
#endif // _ATL_DEBUG_INTERFACES
        } else
            hRes = m_contained._InternalQueryInterface(iid, ppvObject);
        return hRes;
    }
    template <class Q>
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)
    {
        return QueryInterface(__uuidof(Q), (void**)pp);
    }
    static HRESULT WINAPI CreateInstance(LPUNKNOWN pUnkOuter, CComPolyObject<contained>** pp)
    {
        _ATL_VALIDATE_OUT_POINTER(pp);

        HRESULT hRes = E_OUTOFMEMORY;
        CComPolyObject<contained>* p = NULL;
        ATLTRY(p = new CComPolyObject<contained>(pUnkOuter))
            if (p != NULL) {
                p->SetVoid(NULL);
                p->InternalFinalConstructAddRef();
                hRes = p->FinalConstruct();
                p->InternalFinalConstructRelease();
                if (hRes != S_OK) {
                    delete p;
                    p = NULL;
                }
            }
        *pp = p;
        return hRes;
    }

    CComContainedObject<contained> m_contained;
};

template <class Base>
class CComTearOffObject : public Base {
public:
    CComTearOffObject(void* pv)
    {
        ATLASSERT(Base::m_pOwner == NULL);
        Base::m_pOwner = reinterpret_cast<CComObject<Base::_OwnerClass>*>(pv);
        Base::m_pOwner->AddRef();
    }
    // Set refcount to 1 to protect destruction
    ~CComTearOffObject()
    {
        Base::m_dwRef = 1L;
        Base::FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(_GetRawUnknown());
#endif
        Base::m_pOwner->Release();
    }

    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        return Base::m_pOwner->QueryInterface(iid, ppvObject);
    }
};

template <class contained>
class CComCachedTearOffObject :
    public IUnknown,
    public CComObjectRootEx<typename contained::_ThreadModel::ThreadModelNoCS> {
public:
    typedef contained _BaseClass;
    typedef CComObjectRootEx<typename contained::_ThreadModel::ThreadModelNoCS> Base;

    CComCachedTearOffObject(void* pv) 
        //: m_contained(((_BaseClass::_OwnerClass*)pv)->GetControllingUnknown())
    {
        DebugBreak();
        ATLASSERT(m_contained.m_pOwner == NULL);
        m_contained.m_pOwner = reinterpret_cast<CComObject<contained::_OwnerClass>*>(pv);
    }
    //If you get a message that this call is ambiguous then you need to
    // override it in your class and call each base class' version of this
    HRESULT FinalConstruct()
    {
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalConstruct();
        return m_contained.FinalConstruct();
    }
    void FinalRelease()
    {
        CComObjectRootEx<contained::_ThreadModel::ThreadModelNoCS>::FinalRelease();
        m_contained.FinalRelease();
    }
    // Set refcount to 1 to protect destruction
    ~CComCachedTearOffObject()
    {
        Base::m_dwRef = 1L;
        FinalRelease();
#ifdef _ATL_DEBUG_INTERFACES
        _Module.DeleteNonAddRefThunk(this);
#endif
    }


    STDMETHOD_(ULONG, AddRef)() { return Base::InternalAddRef(); }
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = Base::InternalRelease();
        if (l == 0)
            delete this;
        return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
    {
        HRESULT hRes = S_OK;
        if (InlineIsEqualUnknown(iid)) {
            if (ppvObject == NULL)
                return E_POINTER;
            *ppvObject = (void*)(IUnknown*)this;
            AddRef();
#ifdef _ATL_DEBUG_INTERFACES
            _Module.AddThunk((IUnknown**)ppvObject, (LPCTSTR)contained::_GetEntries()[-1].dw, iid);
#endif // _ATL_DEBUG_INTERFACES
        } else
            hRes = m_contained._InternalQueryInterface(iid, ppvObject);
        return hRes;
    }
    CComContainedObject<contained> m_contained;
};

class CComClassFactory :
    public IClassFactory,
    public CComObjectRootEx<CComGlobalsThreadModel> {
public:
    typedef CComObjectRootEx<CComGlobalsThreadModel> Base;
    BEGIN_COM_MAP(CComClassFactory)
        COM_INTERFACE_ENTRY(IClassFactory)
    END_COM_MAP()

    // IClassFactory
    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void** ppvObj)
    {
        ATLASSERT(m_pfnCreateInstance != NULL);
        HRESULT hRes = E_POINTER;
        if (ppvObj != NULL) {
            *ppvObj = NULL;
            // can't ask for anything other than IUnknown when aggregating

            if ((pUnkOuter != NULL) && !InlineIsEqualUnknown(riid)) {
                ATLTRACE2(atlTraceCOM, 0, _T("CComClassFactory: asked for non IUnknown interface while creating an aggregated object"));
                hRes = CLASS_E_NOAGGREGATION;
            } else
                hRes = m_pfnCreateInstance(pUnkOuter, riid, ppvObj);
        }
        return hRes;
    }

    STDMETHOD(LockServer)(BOOL fLock)
    {
        if (fLock)
            _Module.Lock();
        else
            _Module.Unlock();
        return S_OK;
    }
    // helper
    void SetVoid(void* pv)
    {
        m_pfnCreateInstance = (_ATL_CREATORFUNC*)pv;
    }
    _ATL_CREATORFUNC* m_pfnCreateInstance;
};

template <class license>
class CComClassFactory2 :
    public IClassFactory2,
    public CComObjectRootEx<CComGlobalsThreadModel>,
    public license {
public:
    typedef license _LicenseClass;
    typedef CComClassFactory2<license> _ComMapClass;
    typedef CComObjectRootEx<CComGlobalsThreadModel> Base;

    BEGIN_COM_MAP(CComClassFactory2<license>)
        COM_INTERFACE_ENTRY(IClassFactory)
        COM_INTERFACE_ENTRY(IClassFactory2)
    END_COM_MAP()
    // IClassFactory
    STDMETHOD(LockServer)(BOOL fLock)
    {
        if (fLock)
            _Module.Lock();
        else
            _Module.Unlock();
        return S_OK;
    }
    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter,
        REFIID riid, void** ppvObj)
    {
        ATLASSERT(m_pfnCreateInstance != NULL);
        if (ppvObj == NULL)
            return E_POINTER;
        *ppvObj = NULL;
        if (!license::IsLicenseValid())
            return CLASS_E_NOTLICENSED;

        if ((pUnkOuter != NULL) && !InlineIsEqualUnknown(riid))
            return CLASS_E_NOAGGREGATION;
        else
            return m_pfnCreateInstance(pUnkOuter, riid, ppvObj);
    }
    // IClassFactory2
    STDMETHOD(CreateInstanceLic)(IUnknown* pUnkOuter, IUnknown* pUnkReserved,
        REFIID riid, BSTR bstrKey, void** ppvObject)
    {
        ATLASSERT(m_pfnCreateInstance != NULL);
        if (ppvObject == NULL)
            return E_POINTER;
        *ppvObject = NULL;
        if (((bstrKey != NULL) && !license::VerifyLicenseKey(bstrKey)) ||
            ((bstrKey == NULL) && !license::IsLicenseValid()))
            return CLASS_E_NOTLICENSED;
        if ((pUnkOuter != NULL) && !InlineIsEqualUnknown(riid))
            return CLASS_E_NOAGGREGATION;
        else
            return m_pfnCreateInstance(pUnkOuter, riid, ppvObject);
    }
    STDMETHOD(RequestLicKey)(DWORD dwReserved, BSTR* pbstrKey)
    {
        if (pbstrKey == NULL)
            return E_POINTER;
        *pbstrKey = NULL;

        if (!license::IsLicenseValid())
            return CLASS_E_NOTLICENSED;
        return license::GetLicenseKey(dwReserved, pbstrKey) ? S_OK : E_FAIL;
    }
    STDMETHOD(GetLicInfo)(LICINFO* pLicInfo)
    {
        if (pLicInfo == NULL)
            return E_POINTER;
        pLicInfo->cbLicInfo = sizeof(LICINFO);
        pLicInfo->fLicVerified = Base::IsLicenseValid();
        BSTR bstr = NULL;
        pLicInfo->fRuntimeKeyAvail = Base::GetLicenseKey(0, &bstr);
        ::SysFreeString(bstr);
        return S_OK;
    }
    void SetVoid(void* pv)
    {
        m_pfnCreateInstance = (_ATL_CREATORFUNC*)pv;
    }
    _ATL_CREATORFUNC* m_pfnCreateInstance;
};

/////////////////////////////////////////////////////////////////////////////////////////////
// Thread Pooling class factory

class CComClassFactoryAutoThread :
    public IClassFactory,
    public CComObjectRootEx<CComGlobalsThreadModel> {
public:
    typedef CComObjectRootEx<CComGlobalsThreadModel> Base;
    BEGIN_COM_MAP(CComClassFactoryAutoThread)
        COM_INTERFACE_ENTRY(IClassFactory)
    END_COM_MAP()

    // helper
    void SetVoid(void* pv)
    {
        m_pfnCreateInstance = (_ATL_CREATORFUNC*)pv;
    }
    STDMETHODIMP CreateInstance(LPUNKNOWN pUnkOuter,
        REFIID riid, void** ppvObj)
    {
        ATLASSERT(m_pfnCreateInstance != NULL);
        HRESULT hRes = E_POINTER;
        if (ppvObj != NULL) {
            *ppvObj = NULL;
            // cannot aggregate across apartments
            ATLASSERT(pUnkOuter == NULL);
            if (pUnkOuter != NULL)
                hRes = CLASS_E_NOAGGREGATION;
            else
                hRes = _Module.CreateInstance(m_pfnCreateInstance, riid, ppvObj);
        }
        return hRes;
    }
    STDMETHODIMP LockServer(BOOL fLock)
    {
        if (fLock)
            _Module.Lock();
        else
            _Module.Unlock();
        return S_OK;
    }
    _ATL_CREATORFUNC* m_pfnCreateInstance;
};

/////////////////////////////////////////////////////////////////////////////////////////////
// Singleton Class Factory
template <class T>
class CComClassFactorySingleton : public CComClassFactory {
public:
    // IClassFactory
    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void** ppvObj)
    {
        HRESULT hRes = E_POINTER;
        if (ppvObj != NULL) {
            *ppvObj = NULL;
            // aggregation is not supported in Singletons
            ATLASSERT(pUnkOuter == NULL);
            if (pUnkOuter != NULL)
                hRes = CLASS_E_NOAGGREGATION;
            else {
                if (m_Obj.m_hResFinalConstruct != S_OK)
                    hRes = m_Obj.m_hResFinalConstruct;
                else
                    hRes = m_Obj.QueryInterface(riid, ppvObj);
            }
        }
        return hRes;
    }
    CComObjectGlobal<T> m_Obj;
};

template <class T, const CLSID* pclsid = &CLSID_NULL>
class CComCoClass {
public:
    DECLARE_CLASSFACTORY()
    DECLARE_AGGREGATABLE(T)
    typedef T _CoClass;
    static const CLSID& WINAPI GetObjectCLSID() { return *pclsid; }
    static LPCTSTR WINAPI GetObjectDescription() { return NULL; }
    static const struct _ATL_CATMAP_ENTRY* GetCategoryMap() { return NULL; };
    static HRESULT WINAPI Error(LPCOLESTR lpszDesc,
        const IID& iid = GUID_NULL, HRESULT hRes = 0)
    {
        return AtlReportError(GetObjectCLSID(), lpszDesc, iid, hRes);
    }
    static HRESULT WINAPI Error(LPCOLESTR lpszDesc, DWORD dwHelpID,
        LPCOLESTR lpszHelpFile, const IID& iid = GUID_NULL, HRESULT hRes = 0)
    {
        return AtlReportError(GetObjectCLSID(), lpszDesc, dwHelpID, lpszHelpFile,
            iid, hRes);
    }
    static HRESULT WINAPI Error(UINT nID, const IID& iid = GUID_NULL,
        HRESULT hRes = 0, HINSTANCE hInst = _Module.GetResourceInstance())
    {
        return AtlReportError(GetObjectCLSID(), nID, iid, hRes, hInst);
    }
    static HRESULT WINAPI Error(UINT nID, DWORD dwHelpID,
        LPCOLESTR lpszHelpFile, const IID& iid = GUID_NULL,
        HRESULT hRes = 0, HINSTANCE hInst = _Module.GetResourceInstance())
    {
        return AtlReportError(GetObjectCLSID(), nID, dwHelpID, lpszHelpFile,
            iid, hRes, hInst);
    }
#ifndef OLE2ANSI
    static HRESULT WINAPI Error(LPCSTR lpszDesc,
        const IID& iid = GUID_NULL, HRESULT hRes = 0)
    {
        return AtlReportError(GetObjectCLSID(), lpszDesc, iid, hRes);
    }
    static HRESULT WINAPI Error(LPCSTR lpszDesc, DWORD dwHelpID,
        LPCSTR lpszHelpFile, const IID& iid = GUID_NULL, HRESULT hRes = 0)
    {
        return AtlReportError(GetObjectCLSID(), lpszDesc, dwHelpID,
            lpszHelpFile, iid, hRes);
    }
#endif
    template <class Q>
    static HRESULT CreateInstance(IUnknown* punkOuter, Q** pp)
    {
        return T::_CreatorClass::CreateInstance(punkOuter, __uuidof(Q), (void**)pp);
    }
    template <class Q>
    static HRESULT CreateInstance(Q** pp)
    {
        return T::_CreatorClass::CreateInstance(NULL, __uuidof(Q), (void**)pp);
    }
};

// ATL doesn't support multiple LCID's at the same time
// Whatever LCID is queried for first is the one that is used.
class CComTypeInfoHolder {
    // Should be 'protected' but can cause compiler to generate fat code.
public:
    const GUID* m_pguid;
    const GUID* m_plibid;
    WORD m_wMajor;
    WORD m_wMinor;

    ITypeInfo* m_pInfo;
    long m_dwRef;
    struct stringdispid {
        CComBSTR bstr;
        int nLen;
        DISPID id;
        stringdispid() : nLen(0), id(DISPID_UNKNOWN) {}
    };
    stringdispid* m_pMap;
    int m_nCount;

public:
    HRESULT GetTI(LCID lcid, ITypeInfo** ppInfo)
    {
        _ATL_VALIDATE_OUT_POINTER(ppInfo);

        HRESULT hr = S_OK;
        if (m_pInfo == NULL)
            hr = GetTI(lcid);
        *ppInfo = m_pInfo;
        if (m_pInfo != NULL) {
            m_pInfo->AddRef();
            hr = S_OK;
        }
        return hr;
    }
    HRESULT GetTI(LCID lcid);
    HRESULT EnsureTI(LCID lcid)
    {
        HRESULT hr = S_OK;
        if (m_pInfo == NULL || m_pMap == NULL)
            hr = GetTI(lcid);
        return hr;
    }

    // This function is called by the module on exit
    // It is registered through _Module.AddTermFunc()
    static void __stdcall Cleanup(DWORD_PTR dw)
    {
        ATLASSERT(dw != 0);
        if (dw == 0)
            return;

        CComTypeInfoHolder* p = (CComTypeInfoHolder*)dw;
        if (p->m_pInfo != NULL)
            p->m_pInfo->Release();
        p->m_pInfo = NULL;
        delete[] p->m_pMap;
        p->m_pMap = NULL;
    }

    HRESULT GetTypeInfo(UINT /* itinfo */, LCID lcid, ITypeInfo** pptinfo)
    {
        return GetTI(lcid, pptinfo);
    }
    HRESULT GetIDsOfNames(REFIID /* riid */, LPOLESTR* rgszNames, UINT cNames,
        LCID lcid, DISPID* rgdispid)
    {
        HRESULT hRes = EnsureTI(lcid);
        if (m_pInfo != NULL) {
            hRes = E_FAIL;
            if (m_pMap != NULL && cNames == 1) {
                int n = ocslen(rgszNames[0]);
                for (int j = m_nCount - 1; j >= 0; j--) {
                    if ((n == m_pMap[j].nLen) &&
                        (memcmp(m_pMap[j].bstr, rgszNames[0], m_pMap[j].nLen * sizeof(OLECHAR)) == 0)) {
                        rgdispid[0] = m_pMap[j].id;
                        hRes = S_OK;
                        break;
                    }
                }
            }
            if (FAILED(hRes)) {
                hRes = m_pInfo->GetIDsOfNames(rgszNames, cNames, rgdispid);
            }
        }
        return hRes;
    }

    HRESULT Invoke(IDispatch* p, DISPID dispidMember, REFIID /* riid */,
        LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
        EXCEPINFO* pexcepinfo, UINT* puArgErr)
    {
        HRESULT hRes = EnsureTI(lcid);
        if (m_pInfo != NULL)
            hRes = m_pInfo->Invoke(p, dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
        return hRes;
    }

    HRESULT LoadNameCache(ITypeInfo* pTypeInfo)
    {
        ATLASSERT(m_pMap == NULL);
        TYPEATTR* pta;
        HRESULT hr = pTypeInfo->GetTypeAttr(&pta);
        if (SUCCEEDED(hr)) {
            m_nCount = pta->cFuncs;

            stringdispid* pMap = NULL;
            if (m_nCount != 0)
                ATLTRY(pMap = new stringdispid[m_nCount]);
            if (m_nCount != 0 && pMap == NULL) {
                m_nCount = 0;
                return E_OUTOFMEMORY;
            }
            for (int i = 0; i < m_nCount; i++) {
                FUNCDESC* pfd;
                hr = pTypeInfo->GetFuncDesc(i, &pfd);
                if (SUCCEEDED(hr)) {
                    CComBSTR bstrName;
                    hr = pTypeInfo->GetDocumentation(pfd->memid, &bstrName, NULL, NULL, NULL);
                    if (SUCCEEDED(hr)) {
                        pMap[i].bstr.Attach(bstrName.Detach());
                        pMap[i].nLen = SysStringLen(pMap[i].bstr);
                        pMap[i].id = pfd->memid;
                    } else {
                        delete[] m_pMap;
                        m_pMap = NULL;
                        m_nCount = 0;
                        pTypeInfo->ReleaseFuncDesc(pfd);
                        break;
                    }
                    pTypeInfo->ReleaseFuncDesc(pfd);
                } else {
                    delete[] m_pMap;
                    m_pMap = NULL;
                    m_nCount = 0;
                    break;
                }
            }
            m_pMap = pMap;
            pTypeInfo->ReleaseTypeAttr(pta);
        }
        return hr;
    }
};

inline HRESULT CComTypeInfoHolder::GetTI(LCID lcid)
{
    //If this assert occurs then most likely didn't initialize properly
    ATLASSERT(m_plibid != NULL && m_pguid != NULL);
    ATLASSERT(!InlineIsEqualGUID(*m_plibid, GUID_NULL) && "Did you forget to pass the LIBID to CComModule::Init?");

    if (m_pInfo != NULL && m_pMap != NULL)
        return S_OK;
    HRESULT hRes = S_OK;
    EnterCriticalSection(&_Module.m_csTypeInfoHolder);
    if (m_pInfo == NULL) {
        ITypeLib* pTypeLib;
        hRes = LoadRegTypeLib(*m_plibid, m_wMajor, m_wMinor, lcid, &pTypeLib);
        if (SUCCEEDED(hRes)) {
            CComPtr<ITypeInfo> spTypeInfo;
            hRes = pTypeLib->GetTypeInfoOfGuid(*m_pguid, &spTypeInfo);
            if (SUCCEEDED(hRes)) {
                CComPtr<ITypeInfo> spInfo(spTypeInfo);
                CComPtr<ITypeInfo2> spTypeInfo2;
                if (SUCCEEDED(spTypeInfo->QueryInterface(&spTypeInfo2)))
                    spInfo = spTypeInfo2;

                m_pInfo = spInfo.Detach();
                _Module.AddTermFunc(Cleanup, (DWORD_PTR)this);
            }
            pTypeLib->Release();
        }
    }
    if (m_pInfo != NULL && m_pMap == NULL) {
        LoadNameCache(m_pInfo);
    }
    LeaveCriticalSection(&_Module.m_csTypeInfoHolder);
    return hRes;
}

//////////////////////////////////////////////////////////////////////////////
// IObjectWithSite
//
template <class T>
class ATL_NO_VTABLE IObjectWithSiteImpl : public IObjectWithSite {
public:
    STDMETHOD(SetSite)(IUnknown* pUnkSite)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IObjectWithSiteImpl::SetSite\n"));
        T* pT = static_cast<T*>(this);
        pT->m_spUnkSite = pUnkSite;
        return S_OK;
    }
    STDMETHOD(GetSite)(REFIID riid, void** ppvSite)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IObjectWithSiteImpl::GetSite\n"));
        T* pT = static_cast<T*>(this);
        ATLASSERT(ppvSite);
        HRESULT hRes = E_POINTER;
        if (ppvSite != NULL) {
            if (pT->m_spUnkSite)
                hRes = pT->m_spUnkSite->QueryInterface(riid, ppvSite);
            else {
                *ppvSite = NULL;
                hRes = E_FAIL;
            }
        }
        return hRes;
    }

    HRESULT SetChildSite(IUnknown* punkChild)
    {
        if (punkChild == NULL)
            return E_POINTER;

        HRESULT hr;
        CComPtr<IObjectWithSite> spChildSite;
        hr = punkChild->QueryInterface(IID_IObjectWithSite, (void**)&spChildSite);
        if (SUCCEEDED(hr))
            hr = spChildSite->SetSite((IUnknown*)this);

        return hr;
    }

    static HRESULT SetChildSite(IUnknown* punkChild, IUnknown* punkParent)
    {
        return AtlSetChildSite(punkChild, punkParent);
    }

    CComPtr<IUnknown> m_spUnkSite;
};

//////////////////////////////////////////////////////////////////////////////
// IServiceProvider
//
template <class T>
class ATL_NO_VTABLE IServiceProviderImpl : public IServiceProvider {
public:
    STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void** ppvObject)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("IServiceProviderImpl::QueryService\n"));
        _ATL_VALIDATE_OUT_POINTER(ppvObject);
        T* pT = static_cast<T*>(this);
        return pT->_InternalQueryService(guidService, riid, ppvObject);
    }
};

#define BEGIN_SERVICE_MAP(x) public: \
        HRESULT _InternalQueryService(REFGUID guidService, REFIID riid, void** ppvObject) \
        {

#define SERVICE_ENTRY(x) \
                if (InlineIsEqualGUID(guidService, x)) \
                        return QueryInterface(riid, ppvObject);

#define SERVICE_ENTRY_CHAIN(x) \
                CComQIPtr<IServiceProvider, &IID_IServiceProvider> spProvider(x); \
                if (spProvider != NULL) \
                        return spProvider->QueryService(guidService, riid, ppvObject);

#define END_SERVICE_MAP() \
                return E_NOINTERFACE; \
        }


/////////////////////////////////////////////////////////////////////////////
// IDispEventImpl

#ifdef _ATL_DLL
ATLAPI AtlGetObjectSourceInterface(IUnknown* punkObj, GUID* plibid, IID* piid, unsigned short* pdwMajor, unsigned short* pdwMinor);
#else
ATLINLINE ATLAPI AtlGetObjectSourceInterface(IUnknown* punkObj, GUID* plibid, IID* piid, unsigned short* pdwMajor, unsigned short* pdwMinor)
{
    if (plibid == NULL || piid == NULL || pdwMajor == NULL || pdwMinor == NULL)
        return E_POINTER;

    *plibid = GUID_NULL;
    *piid = IID_NULL;
    *pdwMajor = 0;
    *pdwMinor = 0;

    HRESULT hr = E_FAIL;
    if (punkObj != NULL) {
        CComPtr<IDispatch> spDispatch;
        hr = punkObj->QueryInterface(IID_IDispatch, (void**)&spDispatch);
        if (SUCCEEDED(hr)) {
            CComPtr<ITypeInfo> spTypeInfo;
            hr = spDispatch->GetTypeInfo(0, 0, &spTypeInfo);
            if (SUCCEEDED(hr)) {
                CComPtr<ITypeLib> spTypeLib;
                hr = spTypeInfo->GetContainingTypeLib(&spTypeLib, 0);
                if (SUCCEEDED(hr)) {
                    TLIBATTR* plibAttr;
                    hr = spTypeLib->GetLibAttr(&plibAttr);
                    if (SUCCEEDED(hr)) {
                        memcpy(plibid, &plibAttr->guid, sizeof(GUID));
                        *pdwMajor = plibAttr->wMajorVerNum;
                        *pdwMinor = plibAttr->wMinorVerNum;
                        spTypeLib->ReleaseTLibAttr(plibAttr);
                        // First see if the object is willing to tell us about the
                        // default source interface via IProvideClassInfo2
                        CComPtr<IProvideClassInfo2> spInfo;
                        hr = punkObj->QueryInterface(IID_IProvideClassInfo2, (void**)&spInfo);
                        if (SUCCEEDED(hr) && spInfo != NULL)
                            hr = spInfo->GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID, piid);
                        else {
                            // No, we have to go hunt for it
                            CComPtr<ITypeInfo> spInfoCoClass;
                            // If we have a clsid, use that
                            // Otherwise, try to locate the clsid from IPersist
                            CComPtr<IPersist> spPersist;
                            CLSID clsid;
                            hr = punkObj->QueryInterface(IID_IPersist, (void**)&spPersist);
                            if (SUCCEEDED(hr)) {
                                hr = spPersist->GetClassID(&clsid);
                                if (SUCCEEDED(hr)) {
                                    hr = spTypeLib->GetTypeInfoOfGuid(clsid, &spInfoCoClass);
                                    if (SUCCEEDED(hr)) {
                                        TYPEATTR* pAttr = NULL;
                                        spInfoCoClass->GetTypeAttr(&pAttr);
                                        if (pAttr != NULL) {
                                            HREFTYPE hRef;
                                            for (int i = 0; i < pAttr->cImplTypes; i++) {
                                                int nType;
                                                hr = spInfoCoClass->GetImplTypeFlags(i, &nType);
                                                if (SUCCEEDED(hr)) {
                                                    if (nType == (IMPLTYPEFLAG_FDEFAULT | IMPLTYPEFLAG_FSOURCE)) {
                                                        // we found it
                                                        hr = spInfoCoClass->GetRefTypeOfImplType(i, &hRef);
                                                        if (SUCCEEDED(hr)) {
                                                            CComPtr<ITypeInfo> spInfo;
                                                            hr = spInfoCoClass->GetRefTypeInfo(hRef, &spInfo);
                                                            if (SUCCEEDED(hr)) {
                                                                TYPEATTR* pAttrIF;
                                                                spInfo->GetTypeAttr(&pAttrIF);
                                                                if (pAttrIF != NULL) {
                                                                    memcpy(piid, &pAttrIF->guid, sizeof(GUID));
                                                                    spInfo->ReleaseTypeAttr(pAttrIF);
                                                                }
                                                            }
                                                        }
                                                        break;
                                                    }
                                                }
                                            }
                                            spInfoCoClass->ReleaseTypeAttr(pAttr);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return hr;
}
#endif // _ATL_DLL

#if defined(_M_IA64)
template <class T>
class CComStdCallThunk {
public:
    typedef void(__stdcall T::* TMFP)();
    void* pVtable;
    void* pFunc;
    _stdcallthunk thunk;
    void Init(TMFP dw, void* pThis)
    {
        pVtable = &pFunc;
        pFunc = &thunk;
        union {
            DWORD_PTR dwFunc;
            TMFP pfn;
        } pfn;
        pfn.pfn = dw;
        thunk.Init(pfn.dwFunc, pThis);
    }
};
#elif defined(_M_AMD64) || defined(_M_IX86)
template <class T>
class CComStdCallThunk {
public:
    typedef void(__stdcall T::* TMFP)();
    void* pVTable;
    void* pThis;
    TMFP pfn;
    void(__stdcall* pfnHelper)();

    void Init(TMFP pf, void* p);
};

#if defined(_M_AMD64)
#pragma comment(lib, "atlamd64.lib")
extern "C" void CComStdCallThunkHelper(void);
#else

inline void __declspec(naked) __stdcall CComStdCallThunkHelper()
{
    __asm
    {
        mov eax, [esp + 4];       // get pThunk
        mov edx, [eax + 4];       // get the pThunk->pThis
        mov[esp + 4], edx;       // replace pThunk with pThis
        mov eax, [eax + 8];       // get pThunk->pfn
        jmp eax;                // jump pfn
    };
}
#endif

template <class T>
void CComStdCallThunk<T>::Init(TMFP pf, void* p)
{
    pfnHelper = CComStdCallThunkHelper;
    pVTable = &pfnHelper;
    pThis = p;
    pfn = pf;
}

#else
#error "No Target Architecture"
#endif // _M_IX86

#ifndef _ATL_MAX_VARTYPES
#define _ATL_MAX_VARTYPES 8
#endif

struct _ATL_FUNC_INFO {
    CALLCONV cc;
    VARTYPE vtReturn;
    SHORT nParams;
    VARTYPE pVarTypes[_ATL_MAX_VARTYPES];
};

class ATL_NO_VTABLE _IDispEvent {
public:
    _IDispEvent() { m_dwEventCookie = 0xFEFEFEFE; }

    //this method needs a different name than QueryInterface
    STDMETHOD(_LocDEQueryInterface)(REFIID riid, void** ppvObject) = 0;
    virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0;
    virtual ULONG STDMETHODCALLTYPE Release(void) = 0;
    GUID m_libid; // used for dynamic case
    IID m_iid; // used for dynamic case
    unsigned short m_wMajorVerNum;    // Major version number. used for dynamic case
    unsigned short m_wMinorVerNum;    // Minor version number. used for dynamic case
    DWORD m_dwEventCookie;
    HRESULT DispEventAdvise(IUnknown* pUnk, const IID* piid)
    {
        ATLASSERT(m_dwEventCookie == 0xFEFEFEFE);
        return AtlAdvise(pUnk, (IUnknown*)this, *piid, &m_dwEventCookie);
    }
    HRESULT DispEventUnadvise(IUnknown* pUnk, const IID* piid)
    {
        HRESULT hr = AtlUnadvise(pUnk, *piid, m_dwEventCookie);
        m_dwEventCookie = 0xFEFEFEFE;
        return hr;
    }
};

// template <UINT nID, class T, const IID* piid, const GUID* plibid, WORD wMajor, WORD wMinor, class tihclass>
// typename IDispEventImpl<nID, T, piid, plibid, wMajor, wMinor, tihclass>::_tihclass
// IDispEventImpl<nID, T, piid, plibid, wMajor, wMinor, tihclass>::_tih = { piid, plibid, wMajor, wMinor, NULL, 0, NULL, 0 };

template <class T>
struct _ATL_EVENT_ENTRY {
    UINT nControlID;                        //ID identifying object instance
    const IID* piid;                        //dispinterface IID
    INT_PTR nOffset;                        //offset of dispinterface from this pointer
    DISPID dispid;                          //DISPID of method/property
    void(__stdcall T::* pfn)();     //method to invoke
    _ATL_FUNC_INFO* pInfo;
};

template <UINT nID, const IID* piid>
class ATL_NO_VTABLE _IDispEventLocator : public _IDispEvent {
public:
};

template <UINT nID, class T, const IID* pdiid>
class ATL_NO_VTABLE IDispEventSimpleImpl : public _IDispEventLocator<nID, pdiid> {
public:
    typedef _IDispEventLocator<nID, pdiid> Base;
    STDMETHOD(_LocDEQueryInterface)(REFIID riid, void** ppvObject)
    {
        _ATL_VALIDATE_OUT_POINTER(ppvObject);

        if (InlineIsEqualGUID(riid, *pdiid) ||
            InlineIsEqualUnknown(riid) ||
            InlineIsEqualGUID(riid, IID_IDispatch) ||
            InlineIsEqualGUID(riid, Base::m_iid)) {
            *ppvObject = this;
            AddRef();
#ifdef _ATL_DEBUG_INTERFACES
            _Module.AddThunk((IUnknown**)ppvObject, _T("IDispEventImpl"), riid);
#endif // _ATL_DEBUG_INTERFACES
            return S_OK;
        } else
            return E_NOINTERFACE;
    }

    // These are here only to support use in non-COM objects        
    virtual ULONG STDMETHODCALLTYPE AddRef()
    {
        return 1;
    }
    virtual ULONG STDMETHODCALLTYPE Release()
    {
        return 1;
    }

    STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
    {
        return E_NOTIMPL;
    }

    STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
    {
        return E_NOTIMPL;
    }

    STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
        LCID lcid, DISPID* rgdispid)
    {
        return E_NOTIMPL;
    }

    STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,
        LCID lcid, WORD /*wFlags*/, DISPPARAMS* pdispparams, VARIANT* pvarResult,
        EXCEPINFO* /*pexcepinfo*/, UINT* /*puArgErr*/)
    {
        T* pT = static_cast<T*>(this);
        const _ATL_EVENT_ENTRY<T>* pMap = T::_GetSinkMap();
        const _ATL_EVENT_ENTRY<T>* pFound = NULL;
        void(__stdcall T:: * pEvent)() = NULL;
        while (pMap->piid != NULL) {
            if ((pMap->nControlID == nID) && (pMap->dispid == dispidMember) &&
                (pMap->piid == pdiid)) //comparing pointers here should be adequate
            {
                pFound = pMap;
                break;
            }
            pMap++;
        }
        if (pFound == NULL)
            return S_OK;

        _ATL_FUNC_INFO info;
        _ATL_FUNC_INFO* pInfo;
        if (pFound->pInfo != NULL)
            pInfo = pFound->pInfo;
        else {
            pInfo = &info;
            HRESULT hr = GetFuncInfoFromId(*pdiid, dispidMember, lcid, info);
            if (FAILED(hr))
                return S_OK;
        }
        return InvokeFromFuncInfo(pFound->pfn, *pInfo, pdispparams, pvarResult);
    }

    //Helper for invoking the event
    HRESULT InvokeFromFuncInfo(void(__stdcall T::* pEvent)(), _ATL_FUNC_INFO& info, DISPPARAMS* pdispparams, VARIANT* pvarResult)
    {
        T* pT = static_cast<T*>(this);
        // If this assert occurs, then add a #define _ATL_MAX_VARTYPES nnnn
        // before including atlcom.h
        ATLASSERT(info.nParams <= _ATL_MAX_VARTYPES);
        if (info.nParams > _ATL_MAX_VARTYPES) {
            return E_FAIL;
        }
        VARIANTARG* rgVarArgs[_ATL_MAX_VARTYPES];
        VARIANTARG** pVarArgs = info.nParams ? rgVarArgs : 0;

        for (int i = 0; i < info.nParams; i++)
            pVarArgs[i] = &pdispparams->rgvarg[info.nParams - i - 1];

        CComStdCallThunk<T> thunk;
        thunk.Init(pEvent, pT);
        CComVariant tmpResult;
        if (pvarResult == NULL)
            pvarResult = &tmpResult;

        HRESULT hr = DispCallFunc(
            &thunk,
            0,
            info.cc,
            info.vtReturn,
            info.nParams,
            info.pVarTypes,
            pVarArgs,
            pvarResult);
        ATLASSERT(SUCCEEDED(hr));
        return hr;
    }

    //Helper for finding the function index for a DISPID
    virtual HRESULT GetFuncInfoFromId(const IID& iid, DISPID dispidMember, LCID lcid, _ATL_FUNC_INFO& info)
    {
        return E_NOTIMPL;
    }
    //Helpers for sinking events on random IUnknown*
    HRESULT DispEventAdvise(IUnknown* pUnk, const IID* piid)
    {
        ATLASSERT(Base::m_dwEventCookie == 0xFEFEFEFE);
        if (Base::m_dwEventCookie != 0xFEFEFEFE)
            return E_UNEXPECTED;
        return AtlAdvise(pUnk, (IUnknown*)this, *piid, &Base::m_dwEventCookie);
    }
    HRESULT DispEventUnadvise(IUnknown* pUnk, const IID* piid)
    {
        HRESULT hr = AtlUnadvise(pUnk, *piid, Base::m_dwEventCookie);
        Base::m_dwEventCookie = 0xFEFEFEFE;
        return hr;
    }
    HRESULT DispEventAdvise(IUnknown* pUnk)
    {
        return _IDispEvent::DispEventAdvise(pUnk, pdiid);
    }
    HRESULT DispEventUnadvise(IUnknown* pUnk)
    {
        return _IDispEvent::DispEventUnadvise(pUnk, pdiid);
    }
};

//Helper for advising connections points from a sink map
template <class T>
inline HRESULT AtlAdviseSinkMap(T* pT, bool bAdvise)
{
    ATLASSERT(::IsWindow(pT->m_hWnd));
    const _ATL_EVENT_ENTRY<T>* pEntries = T::_GetSinkMap();
    if (pEntries == NULL)
        return S_OK;
    HRESULT hr = S_OK;
    while (pEntries->piid != NULL) {
        _IDispEvent* pDE = (_IDispEvent*)((DWORD_PTR)pT + pEntries->nOffset);
        bool bNotAdvised = pDE->m_dwEventCookie == 0xFEFEFEFE;
        if (bAdvise ^ bNotAdvised) {
            pEntries++;
            continue;
        }
        hr = E_FAIL;
        HWND h = pT->GetDlgItem(pEntries->nControlID);
        ATLASSERT(h != NULL);
        if (h != NULL) {
            CComPtr<IUnknown> spUnk;
            AtlAxGetControl(h, &spUnk);
            ATLASSERT(spUnk != NULL);
            if (spUnk != NULL) {
                if (bAdvise) {
                    if (!InlineIsEqualGUID(IID_NULL, *pEntries->piid))
                        hr = pDE->DispEventAdvise(spUnk, pEntries->piid);
                    else {
                        AtlGetObjectSourceInterface(spUnk, &pDE->m_libid, &pDE->m_iid, &pDE->m_wMajorVerNum, &pDE->m_wMinorVerNum);
                        hr = pDE->DispEventAdvise(spUnk, &pDE->m_iid);
                    }
                } else {
                    if (!InlineIsEqualGUID(IID_NULL, *pEntries->piid))
                        hr = pDE->DispEventUnadvise(spUnk, pEntries->piid);
                    else
                        hr = pDE->DispEventUnadvise(spUnk, &pDE->m_iid);
                }
                ATLASSERT(hr == S_OK);
            }
        }
        if (FAILED(hr))
            break;
        pEntries++;
    }
    return hr;
}

template <UINT nID, class T, const IID* pdiid = &IID_NULL, const GUID* plibid = &GUID_NULL,
    WORD wMajor = 0, WORD wMinor = 0, class tihclass = CComTypeInfoHolder>
    class ATL_NO_VTABLE IDispEventImpl : public IDispEventSimpleImpl<nID, T, pdiid> {
    public:
        typedef tihclass _tihclass;
        typedef IDispEventSimpleImpl<nID, T, pdiid> Base;

        IDispEventImpl()
        {
            Base::m_libid = *plibid;
            Base::m_iid = *pdiid;
            Base::m_wMajorVerNum = wMajor;
            Base::m_wMinorVerNum = wMinor;
        }

        STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
        {
            if (pctinfo == NULL) return E_INVALIDARG; *pctinfo = 1; return S_OK;
        }

        STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
        {
            return _tih.GetTypeInfo(itinfo, lcid, pptinfo);
        }

        STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
            LCID lcid, DISPID* rgdispid)
        {
            return _tih.GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
        }

        //Helper for finding the function index for a DISPID
        HRESULT GetFuncInfoFromId(const IID& /*iid*/, DISPID dispidMember, LCID lcid, _ATL_FUNC_INFO& info)
        {
            CComPtr<ITypeInfo> spTypeInfo;
            if (InlineIsEqualGUID(*_tih.m_plibid, GUID_NULL)) {
                _tih.m_plibid = &Base::m_libid;
                _tih.m_pguid = &Base::m_iid;
                _tih.m_wMajor = Base::m_wMajorVerNum;
                _tih.m_wMinor = Base::m_wMinorVerNum;
            }
            HRESULT hr = _tih.GetTI(lcid, &spTypeInfo);
            if (FAILED(hr))
                return hr;
            CComQIPtr<ITypeInfo2, &IID_ITypeInfo2> spTypeInfo2 = spTypeInfo;
            FUNCDESC* pFuncDesc = NULL;
            if (spTypeInfo2 != NULL) {
                UINT nIndex;
                hr = spTypeInfo2->GetFuncIndexOfMemId(dispidMember, INVOKE_FUNC, &nIndex);
                if (FAILED(hr))
                    return hr;
                hr = spTypeInfo->GetFuncDesc(nIndex, &pFuncDesc);
                if (FAILED(hr))
                    return hr;
            } else // search for funcdesc
            {
                TYPEATTR* pAttr;
                hr = spTypeInfo->GetTypeAttr(&pAttr);
                if (FAILED(hr))
                    return hr;
                for (int i = 0; i < pAttr->cFuncs; i++) {
                    hr = spTypeInfo->GetFuncDesc(i, &pFuncDesc);
                    if (FAILED(hr))
                        return hr;
                    if (pFuncDesc->memid == dispidMember)
                        break;
                    spTypeInfo->ReleaseFuncDesc(pFuncDesc);
                    pFuncDesc = NULL;
                }
                spTypeInfo->ReleaseTypeAttr(pAttr);
                if (pFuncDesc == NULL)
                    return E_FAIL;
            }

            // If this assert occurs, then add a #define _ATL_MAX_VARTYPES nnnn
            // before including atlcom.h
            ATLASSERT(pFuncDesc->cParams <= _ATL_MAX_VARTYPES);
            if (pFuncDesc->cParams > _ATL_MAX_VARTYPES)
                return E_FAIL;

            for (int i = 0; i < pFuncDesc->cParams; i++) {
                info.pVarTypes[i] = pFuncDesc->lprgelemdescParam[i].tdesc.vt;
                if (info.pVarTypes[i] == VT_PTR)
                    info.pVarTypes[i] = pFuncDesc->lprgelemdescParam[i].tdesc.lptdesc->vt | VT_BYREF;
                if (info.pVarTypes[i] == VT_USERDEFINED)
                    info.pVarTypes[i] = GetUserDefinedType(spTypeInfo, pFuncDesc->lprgelemdescParam[i].tdesc.hreftype);
            }

            VARTYPE vtReturn = pFuncDesc->elemdescFunc.tdesc.vt;
            switch (vtReturn) {
            case VT_INT:
                vtReturn = VT_I4;
                break;
            case VT_UINT:
                vtReturn = VT_UI4;
                break;
            case VT_VOID:
                vtReturn = VT_EMPTY; // this is how DispCallFunc() represents void
                break;
            case VT_HRESULT:
                vtReturn = VT_ERROR;
                break;
            }
            info.vtReturn = vtReturn;
            info.cc = pFuncDesc->callconv;
            info.nParams = pFuncDesc->cParams;
            spTypeInfo->ReleaseFuncDesc(pFuncDesc);
            return S_OK;
        }
        VARTYPE GetUserDefinedType(ITypeInfo* pTI, HREFTYPE hrt)
        {
            CComPtr<ITypeInfo> spTypeInfo;
            VARTYPE vt = VT_USERDEFINED;
            HRESULT hr = E_FAIL;
            hr = pTI->GetRefTypeInfo(hrt, &spTypeInfo);
            if (FAILED(hr))
                return vt;
            TYPEATTR* pta = NULL;

            spTypeInfo->GetTypeAttr(&pta);
            if (pta && pta->typekind == TKIND_ALIAS) {
                if (pta->tdescAlias.vt == VT_USERDEFINED)
                    GetUserDefinedType(spTypeInfo, pta->tdescAlias.hreftype);
                else
                    vt = pta->tdescAlias.vt;
            }

            if (pta)
                spTypeInfo->ReleaseTypeAttr(pta);
            return vt;

        }
    protected:
        static _tihclass _tih;
        static HRESULT GetTI(LCID lcid, ITypeInfo** ppInfo)
        {
            return _tih.GetTI(lcid, ppInfo);
        }
};






//Sink map is used to set up event handling
#define BEGIN_SINK_MAP(_class)\
        static const _ATL_EVENT_ENTRY<_class>* _GetSinkMap()\
        {\
                typedef _class _atl_event_classtype;\
                static const _ATL_EVENT_ENTRY<_class> map[] = {


#define SINK_ENTRY_INFO(id, iid, dispid, fn, info) {id, &iid, (INT_PTR)(static_cast<_IDispEventLocator<id, &iid>*>((_atl_event_classtype*)8))-8, dispid, (void (__stdcall _atl_event_classtype::*)())fn, info},
#define SINK_ENTRY_EX(id, iid, dispid, fn) SINK_ENTRY_INFO(id, iid, dispid, fn, NULL)
#define SINK_ENTRY(id, dispid, fn) SINK_ENTRY_EX(id, IID_NULL, dispid, fn)
#define END_SINK_MAP() {0, NULL, 0, 0, NULL, NULL} }; return map;}

/////////////////////////////////////////////////////////////////////////////
// IDispatchImpl

template <class T, const IID* piid, const GUID* plibid = &CComModule::m_libid, WORD wMajor = 1,
    WORD wMinor = 0, class tihclass = CComTypeInfoHolder>
    class ATL_NO_VTABLE IDispatchImpl : public T {
    public:
        typedef tihclass _tihclass;
        // IDispatch
        STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
        {
            if (pctinfo == NULL)
                return E_INVALIDARG;
            *pctinfo = 1;
            return S_OK;
        }
        STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
        {
            return _tih.GetTypeInfo(itinfo, lcid, pptinfo);
        }
        STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
            LCID lcid, DISPID* rgdispid)
        {
            return _tih.GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
        }
        STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,
            LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
            EXCEPINFO* pexcepinfo, UINT* puArgErr)
        {
            return _tih.Invoke((IDispatch*)this, dispidMember, riid, lcid,
                wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
        }
    protected:
        static _tihclass _tih;
        static HRESULT GetTI(LCID lcid, ITypeInfo** ppInfo)
        {
            return _tih.GetTI(lcid, ppInfo);
        }
};

template <class T, const IID* piid, const GUID* plibid, WORD wMajor, WORD wMinor, class tihclass>
typename IDispatchImpl<T, piid, plibid, wMajor, wMinor, tihclass>::_tihclass
IDispatchImpl<T, piid, plibid, wMajor, wMinor, tihclass>::_tih =
{ piid, plibid, wMajor, wMinor, NULL, 0, NULL, 0 };


/////////////////////////////////////////////////////////////////////////////
// IProvideClassInfoImpl
template <const CLSID* pcoclsid, const GUID* plibid = &CComModule::m_libid,
    WORD wMajor = 1, WORD wMinor = 0, class tihclass = CComTypeInfoHolder>
    class ATL_NO_VTABLE IProvideClassInfoImpl : public IProvideClassInfo {
    public:
        typedef tihclass _tihclass;

        STDMETHOD(GetClassInfo)(ITypeInfo** pptinfo)
        {
            return _tih.GetTypeInfo(0, LANG_NEUTRAL, pptinfo);
        }

    protected:
        static _tihclass _tih;
};

template <const CLSID* pcoclsid, const GUID* plibid, WORD wMajor, WORD wMinor, class tihclass>
typename IProvideClassInfoImpl<pcoclsid, plibid, wMajor, wMinor, tihclass>::_tihclass
IProvideClassInfoImpl<pcoclsid, plibid, wMajor, wMinor, tihclass>::_tih =
{ pcoclsid,plibid, wMajor, wMinor, NULL, 0, NULL, 0 };

/////////////////////////////////////////////////////////////////////////////
// IProvideClassInfo2Impl
template <const CLSID* pcoclsid, const IID* psrcid, const GUID* plibid = &CComModule::m_libid,
    WORD wMajor = 1, WORD wMinor = 0, class tihclass = CComTypeInfoHolder>
    class ATL_NO_VTABLE IProvideClassInfo2Impl : public IProvideClassInfo2 {
    public:
        typedef tihclass _tihclass;

        STDMETHOD(GetClassInfo)(ITypeInfo** pptinfo)
        {
            return _tih.GetTypeInfo(0, LANG_NEUTRAL, pptinfo);
        }
        STDMETHOD(GetGUID)(DWORD dwGuidKind, GUID* pGUID)
        {
            if (pGUID == NULL)
                return E_POINTER;

            if (dwGuidKind == GUIDKIND_DEFAULT_SOURCE_DISP_IID && psrcid) {
                *pGUID = *psrcid;
                return S_OK;
            }
            *pGUID = GUID_NULL;
            return E_FAIL;
        }

    protected:
        static _tihclass _tih;
};


template <const CLSID* pcoclsid, const IID* psrcid, const GUID* plibid, WORD wMajor, WORD wMinor, class tihclass>
typename IProvideClassInfo2Impl<pcoclsid, psrcid, plibid, wMajor, wMinor, tihclass>::_tihclass
IProvideClassInfo2Impl<pcoclsid, psrcid, plibid, wMajor, wMinor, tihclass>::_tih =
{ pcoclsid,plibid, wMajor, wMinor, NULL, 0, NULL, 0 };


/////////////////////////////////////////////////////////////////////////////
// ISupportErrorInfoImpl

template <const IID* piid>
class ATL_NO_VTABLE ISupportErrorInfoImpl : public ISupportErrorInfo {
public:
    STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid)
    {
        return (InlineIsEqualGUID(riid, *piid)) ? S_OK : S_FALSE;
    }
};


/////////////////////////////////////////////////////////////////////////////
// CComEnumImpl

// These _CopyXXX classes are used with enumerators in order to control
// how enumerated items are initialized, copied, and deleted

// Default is shallow copy with no special init or cleanup
template <class T>
class _Copy {
public:
    static HRESULT copy(T* p1, T* p2) { memcpy(p1, p2, sizeof(T)); return S_OK; }
    static void init(T*) {}
    static void destroy(T*) {}
};

template<>
class _Copy<VARIANT> {
public:
    static HRESULT copy(VARIANT* p1, VARIANT* p2) { return VariantCopy(p1, p2); }
    static void init(VARIANT* p) { p->vt = VT_EMPTY; }
    static void destroy(VARIANT* p) { VariantClear(p); }
};

template<>
class _Copy<LPOLESTR> {
public:
    static HRESULT copy(LPOLESTR* p1, LPOLESTR* p2)
    {
        HRESULT hr = S_OK;
        (*p1) = (LPOLESTR)CoTaskMemAlloc(sizeof(OLECHAR) * (ocslen(*p2) + 1));
        if (*p1 == NULL)
            hr = E_OUTOFMEMORY;
        else
            ocscpy(*p1, *p2);
        return hr;
    }
    static void init(LPOLESTR* p) { *p = NULL; }
    static void destroy(LPOLESTR* p) { CoTaskMemFree(*p); }
};

template<>
class _Copy<OLEVERB> {
public:
    static HRESULT copy(OLEVERB* p1, OLEVERB* p2)
    {
        HRESULT hr = S_OK;
        *p1 = *p2;
        if (p2->lpszVerbName == NULL)
            return S_OK;
        p1->lpszVerbName = (LPOLESTR)CoTaskMemAlloc(sizeof(OLECHAR) * (ocslen(p2->lpszVerbName) + 1));
        if (p1->lpszVerbName == NULL)
            hr = E_OUTOFMEMORY;
        else
            ocscpy(p1->lpszVerbName, p2->lpszVerbName);
        return hr;
    }
    static void init(OLEVERB* p) { p->lpszVerbName = NULL; }
    static void destroy(OLEVERB* p) { if (p->lpszVerbName) CoTaskMemFree(p->lpszVerbName); }
};

template<>
class _Copy<CONNECTDATA> {
public:
    static HRESULT copy(CONNECTDATA* p1, CONNECTDATA* p2)
    {
        *p1 = *p2;
        if (p1->pUnk)
            p1->pUnk->AddRef();
        return S_OK;
    }
    static void init(CONNECTDATA*) {}
    static void destroy(CONNECTDATA* p) { if (p->pUnk) p->pUnk->Release(); }
};

template <class T>
class _CopyInterface {
public:
    static HRESULT copy(T** p1, T** p2)
    {
        *p1 = *p2;
        if (*p1)
            (*p1)->AddRef();
        return S_OK;
    }
    static void init(T**) {}
    static void destroy(T** p) { if (*p) (*p)->Release(); }
};

template<class T>
class ATL_NO_VTABLE CComIEnum : public IUnknown {
public:
    STDMETHOD(Next)(ULONG celt, T* rgelt, ULONG* pceltFetched) = 0;
    STDMETHOD(Skip)(ULONG celt) = 0;
    STDMETHOD(Reset)(void) = 0;
    STDMETHOD(Clone)(CComIEnum<T>** ppEnum) = 0;
};


enum CComEnumFlags {
    //see FlagBits in CComEnumImpl
    AtlFlagNoCopy = 0,
    AtlFlagTakeOwnership = 2,
    AtlFlagCopy = 3 // copy implies ownership
};

template <class Base, const IID* piid, class T, class Copy>
class ATL_NO_VTABLE CComEnumImpl : public Base {
public:
    CComEnumImpl() { m_begin = m_end = m_iter = NULL; m_dwFlags = 0; }
    ~CComEnumImpl();
    STDMETHOD(Next)(ULONG celt, T* rgelt, ULONG* pceltFetched);
    STDMETHOD(Skip)(ULONG celt);
    STDMETHOD(Reset)(void) { m_iter = m_begin; return S_OK; }
    STDMETHOD(Clone)(Base** ppEnum);
    HRESULT Init(T* begin, T* end, IUnknown* pUnk,
        CComEnumFlags flags = AtlFlagNoCopy);
    CComPtr<IUnknown> m_spUnk;
    T* m_begin;
    T* m_end;
    T* m_iter;
    DWORD m_dwFlags;
protected:
    enum FlagBits {
        BitCopy = 1,
        BitOwn = 2
    };
};

template <class Base, const IID* piid, class T, class Copy>
CComEnumImpl<Base, piid, T, Copy>::~CComEnumImpl()
{
    if (m_dwFlags & BitOwn) {
        for (T* p = m_begin; p != m_end; p++)
            Copy::destroy(p);
        delete[] m_begin;
    }
}

template <class Base, const IID* piid, class T, class Copy>
STDMETHODIMP CComEnumImpl<Base, piid, T, Copy>::Next(ULONG celt, T* rgelt,
    ULONG* pceltFetched)
{
    if ((celt == 0) && (rgelt == NULL) && (NULL != pceltFetched)) {
        // Return the number of remaining elements
        *pceltFetched = (ULONG)(m_end - m_iter);
        return S_OK;
    }
    if (rgelt == NULL || (celt != 1 && pceltFetched == NULL))
        return E_POINTER;
    if (m_begin == NULL || m_end == NULL || m_iter == NULL)
        return E_FAIL;
    ULONG nRem = (ULONG)(m_end - m_iter);
    HRESULT hRes = S_OK;
    if (nRem < celt)
        hRes = S_FALSE;
    ULONG nMin = min(celt, nRem);
    if (pceltFetched != NULL)
        *pceltFetched = nMin;
    T* pelt = rgelt;
    while (nMin--) {
        HRESULT hr = Copy::copy(pelt, m_iter);
        if (FAILED(hr)) {
            while (rgelt < pelt)
                Copy::destroy(rgelt++);
            if (pceltFetched != NULL)
                *pceltFetched = 0;
            return hr;
        }
        pelt++;
        m_iter++;
    }
    return hRes;
}

template <class Base, const IID* piid, class T, class Copy>
STDMETHODIMP CComEnumImpl<Base, piid, T, Copy>::Skip(ULONG celt)
{
    m_iter += celt;
    if (m_iter > m_end) {
        m_iter = m_end;
        return S_FALSE;
    }
    if (m_iter < m_begin) {
        m_iter = m_begin;
        return S_FALSE;
    }
    return S_OK;
}

template <class Base, const IID* piid, class T, class Copy, class ThreadModel>
class ATL_NO_VTABLE CComEnum;

template <class Base, const IID* piid, class T, class Copy>
STDMETHODIMP CComEnumImpl<Base, piid, T, Copy>::Clone(Base** ppEnum)
{
    typedef CComObject<CComEnum<Base, piid, T, Copy> > _class;
    HRESULT hRes = E_POINTER;
    if (ppEnum != NULL) {
        *ppEnum = NULL;
        _class* p;
        hRes = _class::CreateInstance(&p);
        if (SUCCEEDED(hRes)) {
            // If the data is a copy then we need to keep "this" object around
            hRes = p->Init(m_begin, m_end, (m_dwFlags & BitCopy) ? this : m_spUnk);
            if (SUCCEEDED(hRes)) {
                p->m_iter = m_iter;
                hRes = p->_InternalQueryInterface(*piid, (void**)ppEnum);
            }
            if (FAILED(hRes))
                delete p;
        }
    }
    return hRes;
}

template <class Base, const IID* piid, class T, class Copy>
HRESULT CComEnumImpl<Base, piid, T, Copy>::Init(T* begin, T* end, IUnknown* pUnk,
    CComEnumFlags flags)
{
    if (flags == AtlFlagCopy) {
        ATLASSERT(m_begin == NULL); //Init called twice?
        ATLTRY(m_begin = new T[ULONG(end - begin)])
            m_iter = m_begin;
        if (m_begin == NULL)
            return E_OUTOFMEMORY;
        for (T* i = begin; i != end; i++) {
            Copy::init(m_iter);
            HRESULT hr = Copy::copy(m_iter, i);
            if (FAILED(hr)) {
                T* p = m_begin;
                while (p < m_iter)
                    Copy::destroy(p++);
                delete[] m_begin;
                m_begin = m_end = m_iter = NULL;
                return hr;
            }
            m_iter++;
        }
        m_end = m_begin + (end - begin);
    } else {
        m_begin = begin;
        m_end = end;
    }
    m_spUnk = pUnk;
    m_iter = m_begin;
    m_dwFlags = flags;
    return S_OK;
}

template <class Base, const IID* piid, class T, class Copy, class ThreadModel = CComObjectThreadModel>
class ATL_NO_VTABLE CComEnum :
    public CComEnumImpl<Base, piid, T, Copy>,
    public CComObjectRootEx< ThreadModel > {
public:
    typedef CComEnum<Base, piid, T, Copy > _CComEnum;
    typedef CComEnumImpl<Base, piid, T, Copy > _CComEnumBase;

    typedef CComObjectRootEx< ThreadModel > Base;

    BEGIN_COM_MAP(_CComEnum)
        COM_INTERFACE_ENTRY_IID(*piid, _CComEnumBase)
    END_COM_MAP()
};

template <class Base, const IID* piid, class T, class Copy, class CollType>
class ATL_NO_VTABLE IEnumOnSTLImpl : public Base {
public:
    HRESULT Init(IUnknown* pUnkForRelease, CollType& collection)
    {
        m_spUnk = pUnkForRelease;
        m_pcollection = &collection;
        m_iter = m_pcollection->begin();
        return S_OK;
    }
    STDMETHOD(Next)(ULONG celt, T* rgelt, ULONG* pceltFetched);
    STDMETHOD(Skip)(ULONG celt);
    STDMETHOD(Reset)(void)
    {
        if (m_pcollection == NULL)
            return E_FAIL;
        m_iter = m_pcollection->begin();
        return S_OK;
    }
    STDMETHOD(Clone)(Base** ppEnum);
    //Data
    CComPtr<IUnknown> m_spUnk;
    CollType* m_pcollection;
    typename CollType::iterator m_iter;
};

template <class Base, const IID* piid, class T, class Copy, class CollType>
STDMETHODIMP IEnumOnSTLImpl<Base, piid, T, Copy, CollType>::Next(ULONG celt, T* rgelt,
    ULONG* pceltFetched)
{
    if (rgelt == NULL || (celt != 1 && pceltFetched == NULL))
        return E_POINTER;
    if (pceltFetched != NULL)
        *pceltFetched = 0;
    if (m_pcollection == NULL)
        return E_FAIL;

    ULONG nActual = 0;
    HRESULT hr = S_OK;
    T* pelt = rgelt;
    while (SUCCEEDED(hr) && m_iter != m_pcollection->end() && nActual < celt) {
        hr = Copy::copy(pelt, &*m_iter);
        if (FAILED(hr)) {
            while (rgelt < pelt)
                Copy::destroy(rgelt++);
            nActual = 0;
        } else {
            pelt++;
            m_iter++;
            nActual++;
        }
    }
    if (SUCCEEDED(hr)) {
        if (pceltFetched)
            *pceltFetched = nActual;
        if (nActual < celt)
            hr = S_FALSE;
    }
    return hr;
}

template <class Base, const IID* piid, class T, class Copy, class CollType>
STDMETHODIMP IEnumOnSTLImpl<Base, piid, T, Copy, CollType>::Skip(ULONG celt)
{
    HRESULT hr = S_OK;
    while (celt--) {
        if (m_iter != m_pcollection->end())
            m_iter++;
        else {
            hr = S_FALSE;
            break;
        }
    }
    return hr;
}

template <class Base, const IID* piid, class T, class Copy, class CollType, class ThreadModel>
class ATL_NO_VTABLE CComEnumOnSTL;

template <class Base, const IID* piid, class T, class Copy, class CollType>
STDMETHODIMP IEnumOnSTLImpl<Base, piid, T, Copy, CollType>::Clone(Base** ppEnum)
{
    typedef CComObject<CComEnumOnSTL<Base, piid, T, Copy, CollType> > _class;
    HRESULT hRes = E_POINTER;
    if (ppEnum != NULL) {
        *ppEnum = NULL;
        _class* p;
        hRes = _class::CreateInstance(&p);
        if (SUCCEEDED(hRes)) {
            hRes = p->Init(m_spUnk, *m_pcollection);
            if (SUCCEEDED(hRes)) {
                p->m_iter = m_iter;
                hRes = p->_InternalQueryInterface(*piid, (void**)ppEnum);
            }
            if (FAILED(hRes))
                delete p;
        }
    }
    return hRes;
}

template <class Base, const IID* piid, class T, class Copy, class CollType, class ThreadModel = CComObjectThreadModel>
class ATL_NO_VTABLE CComEnumOnSTL :
    public IEnumOnSTLImpl<Base, piid, T, Copy, CollType>,
    public CComObjectRootEx< ThreadModel > {
public:
    typedef CComEnumOnSTL<Base, piid, T, Copy, CollType, ThreadModel > _CComEnum;
    typedef IEnumOnSTLImpl<Base, piid, T, Copy, CollType > _CComEnumBase;
    BEGIN_COM_MAP(_CComEnum)
        COM_INTERFACE_ENTRY_IID(*piid, _CComEnumBase)
    END_COM_MAP()
};

template <class T, class CollType, class ItemType, class CopyItem, class EnumType>
class ICollectionOnSTLImpl : public T {
public:
    STDMETHOD(get_Count)(long* pcount)
    {
        if (pcount == NULL)
            return E_POINTER;
        *pcount = m_coll.size();
        return S_OK;
    }
    STDMETHOD(get_Item)(long Index, ItemType* pvar)
    {
        //Index is 1-based
        if (pvar == NULL)
            return E_POINTER;
        if (Index < 1)
            return E_INVALIDARG;
        HRESULT hr = E_FAIL;
//         Index--;
//         CollType::iterator iter = m_coll.begin();
//         while (iter != m_coll.end() && Index > 0) {
//             iter++;
//             Index--;
//         }
//         if (iter != m_coll.end())
//             hr = CopyItem::copy(pvar, &*iter);
        DebugBreak();
        return hr;
    }
    STDMETHOD(get__NewEnum)(IUnknown** ppUnk)
    {
        if (ppUnk == NULL)
            return E_POINTER;
        *ppUnk = NULL;
        HRESULT hRes = S_OK;
        CComObject<EnumType>* p;
        hRes = CComObject<EnumType>::CreateInstance(&p);
        if (SUCCEEDED(hRes)) {
            hRes = p->Init(this, m_coll);
            if (hRes == S_OK)
                hRes = p->QueryInterface(IID_IUnknown, (void**)ppUnk);
        }
        if (hRes != S_OK)
            delete p;
        return hRes;
    }
    CollType m_coll;
};

//////////////////////////////////////////////////////////////////////////////
// ISpecifyPropertyPagesImpl
template <class T>
class ATL_NO_VTABLE ISpecifyPropertyPagesImpl : public ISpecifyPropertyPages {
public:
    // ISpecifyPropertyPages
    //
    STDMETHOD(GetPages)(CAUUID* pPages)
    {
        ATLTRACE2(atlTraceCOM, 0, _T("ISpecifyPropertyPagesImpl::GetPages\n"));
        ATL_PROPMAP_ENTRY* pMap = T::GetPropertyMap();
        return GetPagesHelper(pPages, pMap);
    }
protected:
    HRESULT GetPagesHelper(CAUUID* pPages, ATL_PROPMAP_ENTRY* pMap)
    {
        if (pPages == NULL)
            return E_POINTER;

        ATLASSERT(pMap != NULL);
        if (pMap == NULL)
            return E_POINTER;

        int nCnt = 0;
        int i;
        // Get count of unique pages to alloc the array
        for (i = 0; pMap[i].pclsidPropPage != NULL; i++) {
            // only allow non data entry types
            if (pMap[i].vt == 0) {
                // Does this property have a page?  CLSID_NULL means it does not
                if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL))
                    nCnt++;
            }
        }
        pPages->pElems = (GUID*)CoTaskMemAlloc(sizeof(CLSID) * nCnt);
        if (pPages->pElems == NULL)
            return E_OUTOFMEMORY;
        // reset count of items we have added to the array
        nCnt = 0;
        for (i = 0; pMap[i].pclsidPropPage != NULL; i++) {
            // only allow non data entry types
            if (pMap[i].vt == 0) {
                // Does this property have a page?  CLSID_NULL means it does not
                if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL)) {
                    BOOL bFound = FALSE;
                    // Search through array we are building up to see
                    // if it is already in there
                    for (int j = 0; j < nCnt; j++) {
                        if (InlineIsEqualGUID(*(pMap[i].pclsidPropPage), pPages->pElems[j])) {
                            // It's already there, so no need to add it again
                            bFound = TRUE;
                            break;
                        }
                    }
                    // If we didn't find it in there then add it
                    if (!bFound)
                        pPages->pElems[nCnt++] = *pMap[i].pclsidPropPage;
                }
            }
        }
        pPages->cElems = nCnt;
        return S_OK;
    }

};

#ifndef _ATL_NO_CONNECTION_POINTS
/////////////////////////////////////////////////////////////////////////////
// Connection Points

struct _ATL_CONNMAP_ENTRY {
    DWORD_PTR dwOffset;
};


// We want the offset of the connection point relative to the connection
// point container base class
#define BEGIN_CONNECTION_POINT_MAP(x)\
        typedef x _atl_conn_classtype;\
        static const _ATL_CONNMAP_ENTRY* GetConnMap(int* pnEntries) {\
        static const _ATL_CONNMAP_ENTRY _entries[] = {
// CONNECTION_POINT_ENTRY computes the offset of the connection point to the
// IConnectionPointContainer interface
#define CONNECTION_POINT_ENTRY(iid){offsetofclass(_ICPLocator<&iid>, _atl_conn_classtype)-\
        offsetofclass(IConnectionPointContainerImpl<_atl_conn_classtype>, _atl_conn_classtype)},
#define END_CONNECTION_POINT_MAP() {(DWORD_PTR)-1} }; \
        if (pnEntries) *pnEntries = sizeof(_entries)/sizeof(_ATL_CONNMAP_ENTRY) - 1; \
        return _entries;}


#ifndef _DEFAULT_VECTORLENGTH
#define _DEFAULT_VECTORLENGTH 4
#endif

template <unsigned int nMaxSize>
class CComUnkArray {
public:
    CComUnkArray()
    {
        memset(m_arr, 0, sizeof(IUnknown*) * nMaxSize);
    }
    DWORD Add(IUnknown* pUnk);
    BOOL Remove(DWORD dwCookie);
    DWORD WINAPI GetCookie(IUnknown** pp)
    {
        ULONG iIndex;

        iIndex = ULONG(pp - begin());
        return(iIndex + 1);
    }
    IUnknown* WINAPI GetUnknown(DWORD dwCookie)
    {
        if (dwCookie == 0) {
            return NULL;
        }

        ULONG iIndex;
        iIndex = dwCookie - 1;
        return(begin()[iIndex]);
    }
    IUnknown** begin()
    {
        return &m_arr[0];
    }
    IUnknown** end()
    {
        return &m_arr[nMaxSize];
    }
protected:
    IUnknown* m_arr[nMaxSize];
};

template <unsigned int nMaxSize>
inline DWORD CComUnkArray<nMaxSize>::Add(IUnknown* pUnk)
{
    for (IUnknown** pp = begin(); pp < end(); pp++) {
        if (*pp == NULL) {
            *pp = pUnk;
            return (DWORD)((pp - begin()) + 1); // return cookie
        }
    }
    // If this fires then you need a larger array
    ATLASSERT(0);
    return 0;
}

template <unsigned int nMaxSize>
inline BOOL CComUnkArray<nMaxSize>::Remove(DWORD dwCookie)
{
    ULONG iIndex;

    iIndex = dwCookie - 1;
    if (iIndex >= nMaxSize) {
        return FALSE;
    }

    begin()[iIndex] = NULL;

    return TRUE;
}

template<>
class CComUnkArray<1> {
public:
    CComUnkArray()
    {
        m_arr[0] = NULL;
    }
    DWORD Add(IUnknown* pUnk)
    {
        if (m_arr[0] != NULL) {
            // If this fires then you need a larger array
            ATLASSERT(0);
            return 0;
        }
        m_arr[0] = pUnk;
        return 1;
    }
    BOOL Remove(DWORD dwCookie)
    {
        if (dwCookie != 1)
            return FALSE;
        m_arr[0] = NULL;
        return TRUE;
    }
    DWORD WINAPI GetCookie(IUnknown** /*pp*/)
    {
        return 1;
    }
    IUnknown* WINAPI GetUnknown(DWORD dwCookie)
    {
        if (dwCookie != 1) {
            return NULL;
        }

        return *begin();
    }
    IUnknown** begin()
    {
        return &m_arr[0];
    }
    IUnknown** end()
    {
        return (&m_arr[0]) + 1;
    }
protected:
    IUnknown* m_arr[1];
};

class CComDynamicUnkArray {
public:
    CComDynamicUnkArray()
    {
        m_nSize = 0;
        m_ppUnk = NULL;
    }

    ~CComDynamicUnkArray()
    {
        if (m_nSize > 1)
            free(m_ppUnk);
    }
    DWORD Add(IUnknown* pUnk);
    BOOL Remove(DWORD dwCookie);
    DWORD WINAPI GetCookie(IUnknown** pp)
    {
        ULONG iIndex;
        iIndex = ULONG(pp - begin());
        return iIndex + 1;
    }
    IUnknown* WINAPI GetUnknown(DWORD dwCookie)
    {
        ULONG iIndex;

        if (dwCookie == 0)
            return NULL;

        iIndex = dwCookie - 1;
        return begin()[iIndex];
    }
    IUnknown** begin()
    {
        return (m_nSize < 2) ? &m_pUnk : m_ppUnk;
    }
    IUnknown** end()
    {
        return (m_nSize < 2) ? (&m_pUnk) + m_nSize : &m_ppUnk[m_nSize];
    }

    IUnknown* GetAt(int nIndex)
    {
        if (nIndex < 0 || nIndex >= m_nSize)
            return NULL;

        return (m_nSize < 2) ? m_pUnk : m_ppUnk[nIndex];
    }
    int GetSize() const
    {
        return m_nSize;
    }

    void clear()
    {
        if (m_nSize > 1)
            free(m_ppUnk);
        m_nSize = 0;
    }
protected:
    union {
        IUnknown** m_ppUnk;
        IUnknown* m_pUnk;
    };
    int m_nSize;
};

inline DWORD CComDynamicUnkArray::Add(IUnknown* pUnk)
{
    ULONG iIndex;

    IUnknown** pp = NULL;
    if (m_nSize == 0) // no connections
    {
        m_pUnk = pUnk;
        m_nSize = 1;
        return 1;
    } else if (m_nSize == 1) {
        //create array
        pp = (IUnknown**)malloc(sizeof(IUnknown*) * _DEFAULT_VECTORLENGTH);
        if (pp == NULL)
            return 0;
        memset(pp, 0, sizeof(IUnknown*) * _DEFAULT_VECTORLENGTH);
        *pp = m_pUnk;
        m_ppUnk = pp;
        m_nSize = _DEFAULT_VECTORLENGTH;
    }
    for (pp = begin(); pp < end(); pp++) {
        if (*pp == NULL) {
            *pp = pUnk;
            iIndex = ULONG(pp - begin());
            return iIndex + 1;
        }
    }
    int nAlloc = m_nSize * 2;
    pp = (IUnknown**)realloc(m_ppUnk, sizeof(IUnknown*) * nAlloc);
    if (pp == NULL)
        return 0;
    m_ppUnk = pp;
    memset(&m_ppUnk[m_nSize], 0, sizeof(IUnknown*) * m_nSize);
    m_ppUnk[m_nSize] = pUnk;
    iIndex = m_nSize;
    m_nSize = nAlloc;
    return iIndex + 1;
}

inline BOOL CComDynamicUnkArray::Remove(DWORD dwCookie)
{
    ULONG iIndex;
    if (dwCookie == NULL)
        return FALSE;
    if (m_nSize == 0)
        return FALSE;
    iIndex = dwCookie - 1;
    if (iIndex >= (ULONG)m_nSize)
        return FALSE;
    if (m_nSize == 1) {
        m_nSize = 0;
        return TRUE;
    }
    begin()[iIndex] = NULL;

    return TRUE;
}

template <const IID* piid>
class ATL_NO_VTABLE _ICPLocator {
public:
    //this method needs a different name than QueryInterface
    STDMETHOD(_LocCPQueryInterface)(REFIID riid, void** ppvObject) = 0;
    virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0; \
        virtual ULONG STDMETHODCALLTYPE Release(void) = 0;
};

template <class T, const IID* piid, class CDV = CComDynamicUnkArray >
class ATL_NO_VTABLE IConnectionPointImpl : public _ICPLocator<piid> {
public:
    typedef CComEnum<IEnumConnections, &IID_IEnumConnections, CONNECTDATA, _Copy<CONNECTDATA> > CComEnumConnections;
    typedef CDV _CDV;
    typedef  _ICPLocator<piid> Base;

    ~IConnectionPointImpl();
    STDMETHOD(_LocCPQueryInterface)(REFIID riid, void** ppvObject)
    {
        _ATL_VALIDATE_OUT_POINTER(ppvObject);

        if (InlineIsEqualGUID(riid, IID_IConnectionPoint) || InlineIsEqualUnknown(riid)) {
            *ppvObject = this;
            Base::AddRef();
#ifdef _ATL_DEBUG_INTERFACES
            _Module.AddThunk((IUnknown**)ppvObject, _T("IConnectionPointImpl"), riid);
#endif // _ATL_DEBUG_INTERFACES
            return S_OK;
        } else
            return E_NOINTERFACE;
    }

    STDMETHOD(GetConnectionInterface)(IID* piid2)
    {
        if (piid2 == NULL)
            return E_POINTER;
        *piid2 = *piid;
        return S_OK;
    }
    STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer** ppCPC)
    {
        T* pT = static_cast<T*>(this);
        // No need to check ppCPC for NULL since QI will do that for us
        return pT->QueryInterface(IID_IConnectionPointContainer, (void**)ppCPC);
    }
    STDMETHOD(Advise)(IUnknown* pUnkSink, DWORD* pdwCookie);
    STDMETHOD(Unadvise)(DWORD dwCookie);
    STDMETHOD(EnumConnections)(IEnumConnections** ppEnum);
    CDV m_vec;
};

template <class T, const IID* piid, class CDV>
IConnectionPointImpl<T, piid, CDV>::~IConnectionPointImpl()
{
    IUnknown** pp = m_vec.begin();
    while (pp < m_vec.end()) {
        if (*pp != NULL)
            (*pp)->Release();
        pp++;
    }
}

template <class T, const IID* piid, class CDV>
STDMETHODIMP IConnectionPointImpl<T, piid, CDV>::Advise(IUnknown* pUnkSink,
    DWORD* pdwCookie)
{
    T* pT = static_cast<T*>(this);
    IUnknown* p;
    HRESULT hRes = S_OK;
    if (pdwCookie != NULL)
        *pdwCookie = 0;
    if (pUnkSink == NULL || pdwCookie == NULL)
        return E_POINTER;
    IID iid;
    GetConnectionInterface(&iid);
    hRes = pUnkSink->QueryInterface(iid, (void**)&p);
    if (SUCCEEDED(hRes)) {
        pT->Lock();
        *pdwCookie = m_vec.Add(p);
        hRes = (*pdwCookie != NULL) ? S_OK : CONNECT_E_ADVISELIMIT;
        pT->Unlock();
        if (hRes != S_OK)
            p->Release();
    } else if (hRes == E_NOINTERFACE)
        hRes = CONNECT_E_CANNOTCONNECT;
    if (FAILED(hRes))
        *pdwCookie = 0;
    return hRes;
}

template <class T, const IID* piid, class CDV>
STDMETHODIMP IConnectionPointImpl<T, piid, CDV>::Unadvise(DWORD dwCookie)
{
    T* pT = static_cast<T*>(this);
    pT->Lock();
    IUnknown* p = m_vec.GetUnknown(dwCookie);
    HRESULT hRes = m_vec.Remove(dwCookie) ? S_OK : CONNECT_E_NOCONNECTION;
    pT->Unlock();
    if (hRes == S_OK && p != NULL)
        p->Release();
    return hRes;
}

template <class T, const IID* piid, class CDV>
STDMETHODIMP IConnectionPointImpl<T, piid, CDV>::EnumConnections(
    IEnumConnections** ppEnum)
{
    if (ppEnum == NULL)
        return E_POINTER;
    *ppEnum = NULL;
    CComObject<CComEnumConnections>* pEnum = NULL;
    ATLTRY(pEnum = new CComObject<CComEnumConnections>)
        if (pEnum == NULL)
            return E_OUTOFMEMORY;
    T* pT = static_cast<T*>(this);
    pT->Lock();
    CONNECTDATA* pcd = NULL;
    ATLTRY(pcd = new CONNECTDATA[ULONG(m_vec.end() - m_vec.begin())])
        if (pcd == NULL) {
            delete pEnum;
            pT->Unlock();
            return E_OUTOFMEMORY;
        }
    CONNECTDATA* pend = pcd;
    // Copy the valid CONNECTDATA's
    for (IUnknown** pp = m_vec.begin(); pp < m_vec.end(); pp++) {
        if (*pp != NULL) {
            (*pp)->AddRef();
            pend->pUnk = *pp;
            pend->dwCookie = m_vec.GetCookie(pp);
            pend++;
        }
    }
    // don't copy the data, but transfer ownership to it
    pEnum->Init(pcd, pend, NULL, AtlFlagTakeOwnership);
    pT->Unlock();
    HRESULT hRes = pEnum->_InternalQueryInterface(IID_IEnumConnections, (void**)ppEnum);
    if (FAILED(hRes))
        delete pEnum;
    return hRes;
}

/////////////////////////////////////////////////////////////////////////////
// IConnectionPointContainerImpl

template <class T>
class ATL_NO_VTABLE IConnectionPointContainerImpl : public IConnectionPointContainer {
    typedef CComEnum<IEnumConnectionPoints,
        &IID_IEnumConnectionPoints, IConnectionPoint*,
        _CopyInterface<IConnectionPoint> >
        CComEnumConnectionPoints;
public:
    STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints** ppEnum)
    {
        if (ppEnum == NULL)
            return E_POINTER;
        *ppEnum = NULL;
        CComEnumConnectionPoints* pEnum = NULL;
        ATLTRY(pEnum = new CComObject<CComEnumConnectionPoints>)
            if (pEnum == NULL)
                return E_OUTOFMEMORY;

        int nCPCount;
        const _ATL_CONNMAP_ENTRY* pEntry = T::GetConnMap(&nCPCount);

        // allocate an initialize a vector of connection point object pointers
        USES_ATL_SAFE_ALLOCA;
        IConnectionPoint** ppCP = (IConnectionPoint**)_ATL_SAFE_ALLOCA(sizeof(IConnectionPoint*) * nCPCount, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
        if (ppCP == NULL) {
            delete pEnum;
            return E_OUTOFMEMORY;
        }

        int i = 0;
        while (pEntry->dwOffset != (DWORD_PTR)-1) {
            ppCP[i++] = (IConnectionPoint*)((INT_PTR)this + pEntry->dwOffset);
            pEntry++;
        }

        // copy the pointers: they will AddRef this object
        HRESULT hRes = pEnum->Init((IConnectionPoint**)&ppCP[0],
            (IConnectionPoint**)&ppCP[nCPCount],
            reinterpret_cast<IConnectionPointContainer*>(this), AtlFlagCopy);
        if (FAILED(hRes)) {
            delete pEnum;
            return hRes;
        }
        hRes = pEnum->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
        if (FAILED(hRes))
            delete pEnum;
        return hRes;
    }
    STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint** ppCP)
    {
        if (ppCP == NULL)
            return E_POINTER;
        *ppCP = NULL;
        HRESULT hRes = CONNECT_E_NOCONNECTION;
        const _ATL_CONNMAP_ENTRY* pEntry = T::GetConnMap(NULL);
        IID iid;
        while (pEntry->dwOffset != (DWORD_PTR)-1) {
            IConnectionPoint* pCP =
                (IConnectionPoint*)((INT_PTR)this + pEntry->dwOffset);
            if (SUCCEEDED(pCP->GetConnectionInterface(&iid)) &&
                InlineIsEqualGUID(riid, iid)) {
                *ppCP = pCP;
                pCP->AddRef();
                hRes = S_OK;
                break;
            }
            pEntry++;
        }
        return hRes;
    }
};


#endif //!_ATL_NO_CONNECTION_POINTS

#pragma pack(pop)

/////////////////////////////////////////////////////////////////////////////
// CComAutoThreadModule

template <class ThreadAllocator>
inline HRESULT CComAutoThreadModule<ThreadAllocator>::Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, const GUID* plibid, int nThreads)
{
    m_nThreads = nThreads;
    m_pApartments = NULL;
    ATLTRY(m_pApartments = new CComApartment[m_nThreads]);
    ATLASSERT(m_pApartments != NULL);
    if (m_pApartments == NULL)
        return E_OUTOFMEMORY;
    for (int i = 0; i < nThreads; i++) {
        m_pApartments[i].m_hThread = CreateThread(NULL, 0, CComApartment::_Apartment, (void*)&m_pApartments[i], 0, &m_pApartments[i].m_dwThreadID);
        if (m_pApartments[i].m_hThread == NULL)
            return AtlHresultFromLastError();
    }

    CComApartment::ATL_CREATE_OBJECT = RegisterWindowMessage(_T("ATL_CREATE_OBJECT"));
    return CComModule::Init(p, h, plibid);
}

template <class ThreadAllocator>
inline LONG CComAutoThreadModule<ThreadAllocator>::Lock()
{
    LONG l = CComModule::Lock();
    DWORD dwThreadID = GetCurrentThreadId();
    for (int i = 0; i < m_nThreads; i++) {
        if (m_pApartments[i].m_dwThreadID == dwThreadID) {
            m_pApartments[i].Lock();
            break;
        }
    }
    return l;
}

template <class ThreadAllocator>
inline LONG CComAutoThreadModule<ThreadAllocator>::Unlock()
{
    LONG l = CComModule::Unlock();
    DWORD dwThreadID = GetCurrentThreadId();
    for (int i = 0; i < m_nThreads; i++) {
        if (m_pApartments[i].m_dwThreadID == dwThreadID) {
            m_pApartments[i].Unlock();
            break;
        }
    }
    return l;
}

template <class ThreadAllocator>
HRESULT CComAutoThreadModule<ThreadAllocator>::CreateInstance(void* pfnCreateInstance, REFIID riid, void** ppvObj)
{
    _ATL_CREATORFUNC* pFunc = (_ATL_CREATORFUNC*)pfnCreateInstance;
    _AtlAptCreateObjData data;
    data.pfnCreateInstance = pFunc;
    data.piid = &riid;
    data.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    data.hRes = S_OK;
    int nThread = m_Allocator.GetThread(m_pApartments, m_nThreads);

    int nIterations = 0;
    while (::PostThreadMessage(m_pApartments[nThread].m_dwThreadID, CComApartment::ATL_CREATE_OBJECT, 0, (LPARAM)&data) == 0
        && ++nIterations < 100) {
        Sleep(100);
    }

    if (nIterations < 100) {
        AtlWaitWithMessageLoop(data.hEvent);
    } else {
        data.hRes = AtlHresultFromLastError();
    }

    CloseHandle(data.hEvent);
    if (SUCCEEDED(data.hRes))
        data.hRes = CoGetInterfaceAndReleaseStream(data.pStream, riid, ppvObj);
    return data.hRes;
}

template <class ThreadAllocator>
CComAutoThreadModule<ThreadAllocator>::~CComAutoThreadModule()
{
    for (int i = 0; i < m_nThreads; i++) {
        ::PostThreadMessage(m_pApartments[i].m_dwThreadID, WM_QUIT, 0, 0);
        ::WaitForSingleObject(m_pApartments[i].m_hThread, INFINITE);
        ::CloseHandle(m_pApartments[i].m_hThread);
    }
    delete[] m_pApartments;
}


}; //namespace ATL

#endif // __ATLCOM_H__

   /////////////////////////////////////////////////////////////////////////////
